projects / wxWidgets.git / blob
? search:


8786675fb1859e7ebed7da48956be84f5ff606cb
[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_wxEvtHandler swig_types[51]
2518 #define SWIGTYPE_p_wxFSFile swig_types[52]
2519 #define SWIGTYPE_p_wxFileConfig swig_types[53]
2520 #define SWIGTYPE_p_wxFileDataObject swig_types[54]
2521 #define SWIGTYPE_p_wxFileHistory swig_types[55]
2522 #define SWIGTYPE_p_wxFileSystem swig_types[56]
2523 #define SWIGTYPE_p_wxFileType swig_types[57]
2524 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
2525 #define SWIGTYPE_p_wxFlexGridSizer swig_types[59]
2526 #define SWIGTYPE_p_wxFocusEvent swig_types[60]
2527 #define SWIGTYPE_p_wxFont swig_types[61]
2528 #define SWIGTYPE_p_wxFrame swig_types[62]
2529 #define SWIGTYPE_p_wxGBSizerItem swig_types[63]
2530 #define SWIGTYPE_p_wxGIFHandler swig_types[64]
2531 #define SWIGTYPE_p_wxGridBagSizer swig_types[65]
2532 #define SWIGTYPE_p_wxGridSizer swig_types[66]
2533 #define SWIGTYPE_p_wxICOHandler swig_types[67]
2534 #define SWIGTYPE_p_wxIcon swig_types[68]
2535 #define SWIGTYPE_p_wxIconizeEvent swig_types[69]
2536 #define SWIGTYPE_p_wxIdleEvent swig_types[70]
2537 #define SWIGTYPE_p_wxImage swig_types[71]
2538 #define SWIGTYPE_p_wxImageHandler swig_types[72]
2539 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[73]
2540 #define SWIGTYPE_p_wxInitDialogEvent swig_types[74]
2541 #define SWIGTYPE_p_wxJPEGHandler swig_types[75]
2542 #define SWIGTYPE_p_wxJoystick swig_types[76]
2543 #define SWIGTYPE_p_wxJoystickEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKeyEvent swig_types[78]
2545 #define SWIGTYPE_p_wxKillError swig_types[79]
2546 #define SWIGTYPE_p_wxLayoutConstraints swig_types[80]
2547 #define SWIGTYPE_p_wxLog swig_types[81]
2548 #define SWIGTYPE_p_wxLogBuffer swig_types[82]
2549 #define SWIGTYPE_p_wxLogChain swig_types[83]
2550 #define SWIGTYPE_p_wxLogGui swig_types[84]
2551 #define SWIGTYPE_p_wxLogNull swig_types[85]
2552 #define SWIGTYPE_p_wxLogStderr swig_types[86]
2553 #define SWIGTYPE_p_wxLogTextCtrl swig_types[87]
2554 #define SWIGTYPE_p_wxLogWindow swig_types[88]
2555 #define SWIGTYPE_p_wxMaximizeEvent swig_types[89]
2556 #define SWIGTYPE_p_wxMenu swig_types[90]
2557 #define SWIGTYPE_p_wxMenuBar swig_types[91]
2558 #define SWIGTYPE_p_wxMenuEvent swig_types[92]
2559 #define SWIGTYPE_p_wxMenuItem swig_types[93]
2560 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2561 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseEvent swig_types[98]
2565 #define SWIGTYPE_p_wxMouseState swig_types[99]
2566 #define SWIGTYPE_p_wxMoveEvent swig_types[100]
2567 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[101]
2568 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNcPaintEvent swig_types[103]
2570 #define SWIGTYPE_p_wxNotifyEvent swig_types[104]
2571 #define SWIGTYPE_p_wxObject swig_types[105]
2572 #define SWIGTYPE_p_wxOutputStream swig_types[106]
2573 #define SWIGTYPE_p_wxPCXHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNGHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPNMHandler swig_types[109]
2576 #define SWIGTYPE_p_wxPaintEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[111]
2578 #define SWIGTYPE_p_wxPaperSize swig_types[112]
2579 #define SWIGTYPE_p_wxPlatformInfo swig_types[113]
2580 #define SWIGTYPE_p_wxPoint swig_types[114]
2581 #define SWIGTYPE_p_wxPowerEvent swig_types[115]
2582 #define SWIGTYPE_p_wxProcessEvent swig_types[116]
2583 #define SWIGTYPE_p_wxPyApp swig_types[117]
2584 #define SWIGTYPE_p_wxPyArtProvider swig_types[118]
2585 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[119]
2586 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
2587 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[121]
2588 #define SWIGTYPE_p_wxPyDropSource swig_types[122]
2589 #define SWIGTYPE_p_wxPyDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyEvent swig_types[124]
2591 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[125]
2592 #define SWIGTYPE_p_wxPyImageHandler swig_types[126]
2593 #define SWIGTYPE_p_wxPyLog swig_types[127]
2594 #define SWIGTYPE_p_wxPyProcess swig_types[128]
2595 #define SWIGTYPE_p_wxPySizer swig_types[129]
2596 #define SWIGTYPE_p_wxPyTextDataObject swig_types[130]
2597 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[131]
2598 #define SWIGTYPE_p_wxPyTimer swig_types[132]
2599 #define SWIGTYPE_p_wxPyTipProvider swig_types[133]
2600 #define SWIGTYPE_p_wxPyValidator swig_types[134]
2601 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[135]
2602 #define SWIGTYPE_p_wxRect swig_types[136]
2603 #define SWIGTYPE_p_wxScrollEvent swig_types[137]
2604 #define SWIGTYPE_p_wxScrollWinEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSetCursorEvent swig_types[139]
2606 #define SWIGTYPE_p_wxShowEvent swig_types[140]
2607 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[141]
2608 #define SWIGTYPE_p_wxSize swig_types[142]
2609 #define SWIGTYPE_p_wxSizeEvent swig_types[143]
2610 #define SWIGTYPE_p_wxSizer swig_types[144]
2611 #define SWIGTYPE_p_wxSizerItem swig_types[145]
2612 #define SWIGTYPE_p_wxSound swig_types[146]
2613 #define SWIGTYPE_p_wxStandardPaths swig_types[147]
2614 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[148]
2615 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[149]
2616 #define SWIGTYPE_p_wxStopWatch swig_types[150]
2617 #define SWIGTYPE_p_wxString swig_types[151]
2618 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[152]
2619 #define SWIGTYPE_p_wxSystemOptions swig_types[153]
2620 #define SWIGTYPE_p_wxSystemSettings swig_types[154]
2621 #define SWIGTYPE_p_wxTGAHandler swig_types[155]
2622 #define SWIGTYPE_p_wxTIFFHandler swig_types[156]
2623 #define SWIGTYPE_p_wxTextCtrl swig_types[157]
2624 #define SWIGTYPE_p_wxTextDataObject swig_types[158]
2625 #define SWIGTYPE_p_wxTimeSpan swig_types[159]
2626 #define SWIGTYPE_p_wxTimer swig_types[160]
2627 #define SWIGTYPE_p_wxTimerEvent swig_types[161]
2628 #define SWIGTYPE_p_wxTimerRunner swig_types[162]
2629 #define SWIGTYPE_p_wxTipProvider swig_types[163]
2630 #define SWIGTYPE_p_wxToolTip swig_types[164]
2631 #define SWIGTYPE_p_wxURLDataObject swig_types[165]
2632 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[166]
2633 #define SWIGTYPE_p_wxValidator swig_types[167]
2634 #define SWIGTYPE_p_wxVideoMode swig_types[168]
2635 #define SWIGTYPE_p_wxWindow swig_types[169]
2636 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[170]
2637 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[171]
2638 #define SWIGTYPE_p_wxWindowDisabler swig_types[172]
2639 #define SWIGTYPE_p_wxXPMHandler swig_types[173]
2640 static swig_type_info *swig_types[175];
2641 static swig_module_info swig_module = {swig_types, 174, 0, 0, 0, 0};
2642 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2643 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2644
2645 /* -------- TYPES TABLE (END) -------- */
2646
2647 #if (PY_VERSION_HEX <= 0x02000000)
2648 # if !defined(SWIG_PYTHON_CLASSIC)
2649 # error "This python version requires to use swig with the '-classic' option"
2650 # endif
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodern' option"
2654 #endif
2655 #if (PY_VERSION_HEX <= 0x02020000)
2656 # error "This python version requires to use swig with the '-nomodernargs' option"
2657 #endif
2658 #ifndef METH_O
2659 # error "This python version requires to use swig with the '-nofastunpack' option"
2660 #endif
2661
2662 /*-----------------------------------------------
2663 @(target):= _misc_.so
2664 ------------------------------------------------*/
2665 #define SWIG_init init_misc_
2666
2667 #define SWIG_name "_misc_"
2668
2669 #define SWIGVERSION 0x010329
2670
2671
2672 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2673 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2674
2675
2676 #include <stdexcept>
2677
2678
2679 namespace swig {
2680 class PyObject_ptr {
2681 protected:
2682 PyObject *_obj;
2683
2684 public:
2685 PyObject_ptr() :_obj(0)
2686 {
2687 }
2688
2689 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2690 {
2691 Py_XINCREF(_obj);
2692 }
2693
2694 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2695 {
2696 if (initial_ref) Py_XINCREF(_obj);
2697 }
2698
2699 PyObject_ptr & operator=(const PyObject_ptr& item)
2700 {
2701 Py_XINCREF(item._obj);
2702 Py_XDECREF(_obj);
2703 _obj = item._obj;
2704 return *this;
2705 }
2706
2707 ~PyObject_ptr()
2708 {
2709 Py_XDECREF(_obj);
2710 }
2711
2712 operator PyObject *() const
2713 {
2714 return _obj;
2715 }
2716
2717 PyObject *operator->() const
2718 {
2719 return _obj;
2720 }
2721 };
2722 }
2723
2724
2725 namespace swig {
2726 struct PyObject_var : PyObject_ptr {
2727 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2728
2729 PyObject_var & operator = (PyObject* obj)
2730 {
2731 Py_XDECREF(_obj);
2732 _obj = obj;
2733 return *this;
2734 }
2735 };
2736 }
2737
2738
2739 #include "wx/wxPython/wxPython.h"
2740 #include "wx/wxPython/pyclasses.h"
2741 #include "wx/wxPython/pyistream.h"
2742
2743 static const wxString wxPyEmptyString(wxEmptyString);
2744
2745
2746
2747 #define SWIG_From_long PyInt_FromLong
2748
2749
2750 SWIGINTERNINLINE PyObject *
2751 SWIG_From_int (int value)
2752 {
2753 return SWIG_From_long (value);
2754 }
2755
2756
2757 #include <limits.h>
2758 #ifndef LLONG_MIN
2759 # define LLONG_MIN LONG_LONG_MIN
2760 #endif
2761 #ifndef LLONG_MAX
2762 # define LLONG_MAX LONG_LONG_MAX
2763 #endif
2764 #ifndef ULLONG_MAX
2765 # define ULLONG_MAX ULONG_LONG_MAX
2766 #endif
2767
2768
2769 SWIGINTERN int
2770 SWIG_AsVal_long (PyObject* obj, long* val)
2771 {
2772 if (PyNumber_Check(obj)) {
2773 if (val) *val = PyInt_AsLong(obj);
2774 return SWIG_OK;
2775 }
2776 return SWIG_TypeError;
2777 }
2778
2779
2780 SWIGINTERN int
2781 SWIG_AsVal_int (PyObject * obj, int *val)
2782 {
2783 long v;
2784 int res = SWIG_AsVal_long (obj, &v);
2785 if (SWIG_IsOK(res)) {
2786 if ((v < INT_MIN || v > INT_MAX)) {
2787 return SWIG_OverflowError;
2788 } else {
2789 if (val) *val = static_cast< int >(v);
2790 }
2791 }
2792 return res;
2793 }
2794
2795 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2796
2797 #include <wx/stockitem.h>
2798
2799 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2800 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2801 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2802
2803 SWIGINTERN int
2804 SWIG_AsVal_bool (PyObject *obj, bool *val)
2805 {
2806 if (obj == Py_True) {
2807 if (val) *val = true;
2808 return SWIG_OK;
2809 } else if (obj == Py_False) {
2810 if (val) *val = false;
2811 return SWIG_OK;
2812 } else {
2813 long v = 0;
2814 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2815 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2816 return res;
2817 }
2818 }
2819
2820
2821 wxMemorySize wxGetFreeMemory()
2822 { wxPyRaiseNotImplemented(); return 0; }
2823
2824
2825 SWIGINTERN int
2826 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2827 {
2828 long v = 0;
2829 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2830 return SWIG_TypeError;
2831 }
2832 else if (val)
2833 *val = (unsigned long)v;
2834 return SWIG_OK;
2835 }
2836
2837
2838 SWIGINTERNINLINE PyObject*
2839 SWIG_From_unsigned_SS_long (unsigned long value)
2840 {
2841 return (value > LONG_MAX) ?
2842 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2843 }
2844
2845
2846 void* wxGetXDisplay()
2847 {
2848 #ifdef __WXGTK__
2849 return wxGetDisplay();
2850 #else
2851 return NULL;
2852 #endif
2853 }
2854
2855
2856 wxWindow* FindWindowAtPointer() {
2857 wxPoint unused;
2858 return wxFindWindowAtPointer(unused);
2859 }
2860
2861
2862 void wxWakeUpMainThread() {}
2863
2864
2865 bool wxThread_IsMain() {
2866 #ifdef WXP_WITH_THREAD
2867 return wxThread::IsMain();
2868 #else
2869 return true;
2870 #endif
2871 }
2872
2873 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2874 delete self;
2875 }
2876
2877 #include <wx/snglinst.h>
2878
2879
2880 #ifdef __WXMSW__
2881 #include <wx/msw/private.h>
2882 #include <wx/dynload.h>
2883 #endif
2884
2885
2886
2887 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2888 #if 0
2889 , int method
2890 #endif
2891 )
2892 {
2893 #ifdef __WXMSW__
2894 #if 0
2895 switch (method)
2896 {
2897 case 1:
2898 // This one only partially works. Appears to be an undocumented
2899 // "standard" convention that not all widgets adhear to. For
2900 // example, for some widgets backgrounds or non-client areas may
2901 // not be painted.
2902 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2903 break;
2904
2905 case 2:
2906 #endif
2907 // This one works much better, nearly all widgets and their
2908 // children are captured correctly[**]. Prior to the big
2909 // background erase changes that Vadim did in 2004-2005 this
2910 // method failed badly on XP with Themes activated, most native
2911 // widgets draw only partially, if at all. Without themes it
2912 // worked just like on Win2k. After those changes this method
2913 // works very well.
2914 //
2915 // ** For example the radio buttons in a wxRadioBox are not its
2916 // children by default, but you can capture it via the panel
2917 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2918 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2919 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2920 PRF_ERASEBKGND | PRF_OWNED );
2921 return true;
2922 #if 0
2923 break;
2924
2925 case 3:
2926 // This one is only defined in the latest SDK and is only
2927 // available on XP. MSDN says it is similar to sending WM_PRINT
2928 // so I expect that it will work similar to the above. Since it
2929 // is avaialble only on XP, it can't be compiled like this and
2930 // will have to be loaded dynamically.
2931 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2932
2933 // fall through
2934
2935 case 4:
2936 // Use PrintWindow if available, or fallback to WM_PRINT
2937 // otherwise. Unfortunately using PrintWindow is even worse than
2938 // WM_PRINT. For most native widgets nothing is drawn to the dc
2939 // at all, with or without Themes.
2940 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2941 static bool s_triedToLoad = false;
2942 static PrintWindow_t pfnPrintWindow = NULL;
2943 if ( !s_triedToLoad )
2944 {
2945
2946 s_triedToLoad = true;
2947 wxDynamicLibrary dllUser32(_T("user32.dll"));
2948 if ( dllUser32.IsLoaded() )
2949 {
2950 wxLogNull nolog; // Don't report errors here
2951 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2952 }
2953 }
2954 if (pfnPrintWindow)
2955 {
2956 //printf("Using PrintWindow\n");
2957 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2958 }
2959 else
2960 {
2961 //printf("Using WM_PRINT\n");
2962 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2963 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2964 PRF_ERASEBKGND | PRF_OWNED );
2965 }
2966 }
2967 #endif // 0
2968 #else
2969 return false;
2970 #endif // __WXMSW__
2971 }
2972
2973
2974
2975 #include <wx/tipdlg.h>
2976
2977
2978 SWIGINTERNINLINE PyObject *
2979 SWIG_From_size_t (size_t value)
2980 {
2981 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2982 }
2983
2984
2985 class wxPyTipProvider : public wxTipProvider {
2986 public:
2987 wxPyTipProvider(size_t currentTip)
2988 : wxTipProvider(currentTip) {}
2989
2990 DEC_PYCALLBACK_STRING__pure(GetTip);
2991 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2992 PYPRIVATE;
2993 };
2994
2995 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2996 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2997
2998
2999 SWIGINTERNINLINE int
3000 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3001 {
3002 unsigned long v;
3003 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3004 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3005 return res;
3006 }
3007
3008
3009 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3010
3011 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3012
3013 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3014 : wxTimer(owner, id)
3015 {
3016 if (owner == NULL)
3017 SetOwner(this);
3018 }
3019
3020 wxPyTimer::~wxPyTimer()
3021 {
3022 // printf("-=* ~wxPyTimer\n");
3023 }
3024
3025
3026
3027 SWIGINTERN swig_type_info*
3028 SWIG_pchar_descriptor()
3029 {
3030 static int init = 0;
3031 static swig_type_info* info = 0;
3032 if (!init) {
3033 info = SWIG_TypeQuery("_p_char");
3034 init = 1;
3035 }
3036 return info;
3037 }
3038
3039
3040 SWIGINTERNINLINE PyObject *
3041 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3042 {
3043 if (carray) {
3044 if (size > INT_MAX) {
3045 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3046 return pchar_descriptor ?
3047 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3048 } else {
3049 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3050 }
3051 } else {
3052 return SWIG_Py_Void();
3053 }
3054 }
3055
3056
3057 SWIGINTERNINLINE PyObject *
3058 SWIG_FromCharPtr(const char *cptr)
3059 {
3060 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3061 }
3062
3063
3064 SWIGINTERN int
3065 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3066 {
3067 unsigned long v;
3068 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3069 if (SWIG_IsOK(res)) {
3070 if ((v > UINT_MAX)) {
3071 return SWIG_OverflowError;
3072 } else {
3073 if (val) *val = static_cast< unsigned int >(v);
3074 }
3075 }
3076 return res;
3077 }
3078
3079 SWIGINTERN wxString wxLog_TimeStamp(){
3080 wxString msg;
3081 wxLog::TimeStamp(&msg);
3082 return msg;
3083 }
3084 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3085 // Make some wrappers that double any % signs so they are 'escaped'
3086 void wxPyLogFatalError(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogFatalError(m);
3091 }
3092
3093 void wxPyLogError(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogError(m);
3098 }
3099
3100 void wxPyLogWarning(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogWarning(m);
3105 }
3106
3107 void wxPyLogMessage(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogMessage(m);
3112 }
3113
3114 void wxPyLogInfo(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogInfo(m);
3119 }
3120
3121 void wxPyLogDebug(const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogDebug(m);
3126 }
3127
3128 void wxPyLogVerbose(const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogVerbose(m);
3133 }
3134
3135 void wxPyLogStatus(const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogStatus(m);
3140 }
3141
3142 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogStatus(pFrame, m);
3147 }
3148
3149 void wxPyLogSysError(const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogSysError(m);
3154 }
3155
3156 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3157 {
3158 wxString m(msg);
3159 m.Replace(wxT("%"), wxT("%%"));
3160 wxLogGeneric(level, m);
3161 }
3162
3163 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3164 {
3165 wxString m(msg);
3166 m.Replace(wxT("%"), wxT("%%"));
3167 wxLogTrace(mask, m);
3168 }
3169
3170 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3171 {
3172 wxString m(msg);
3173 m.Replace(wxT("%"), wxT("%%"));
3174 wxLogTrace(mask, m);
3175 }
3176
3177
3178
3179 // A wxLog class that can be derived from in wxPython
3180 class wxPyLog : public wxLog {
3181 public:
3182 wxPyLog() : wxLog() {}
3183
3184 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3185 bool found;
3186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3187 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3188 PyObject* s = wx2PyString(szString);
3189 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3190 Py_DECREF(s);
3191 }
3192 wxPyEndBlockThreads(blocked);
3193 if (! found)
3194 wxLog::DoLog(level, szString, t);
3195 }
3196
3197 virtual void DoLogString(const wxChar *szString, time_t t) {
3198 bool found;
3199 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3200 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3201 PyObject* s = wx2PyString(szString);
3202 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3203 Py_DECREF(s);
3204 }
3205 wxPyEndBlockThreads(blocked);
3206 if (! found)
3207 wxLog::DoLogString(szString, t);
3208 }
3209
3210 DEC_PYCALLBACK_VOID_(Flush);
3211 PYPRIVATE;
3212 };
3213 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3214
3215
3216
3217
3218 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3219
3220
3221 #include <wx/joystick.h>
3222
3223
3224 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3225 // A C++ stub class for wxJoystick for platforms that don't have it.
3226 class wxJoystick : public wxObject {
3227 public:
3228 wxJoystick(int joystick = wxJOYSTICK1) {
3229 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3230 PyErr_SetString(PyExc_NotImplementedError,
3231 "wxJoystick is not available on this platform.");
3232 wxPyEndBlockThreads(blocked);
3233 }
3234 wxPoint GetPosition() { return wxPoint(-1,-1); }
3235 int GetZPosition() { return -1; }
3236 int GetButtonState() { return -1; }
3237 int GetPOVPosition() { return -1; }
3238 int GetPOVCTSPosition() { return -1; }
3239 int GetRudderPosition() { return -1; }
3240 int GetUPosition() { return -1; }
3241 int GetVPosition() { return -1; }
3242 int GetMovementThreshold() { return -1; }
3243 void SetMovementThreshold(int threshold) {}
3244
3245 bool IsOk(void) { return false; }
3246 int GetNumberJoysticks() { return -1; }
3247 int GetManufacturerId() { return -1; }
3248 int GetProductId() { return -1; }
3249 wxString GetProductName() { return wxEmptyString; }
3250 int GetXMin() { return -1; }
3251 int GetYMin() { return -1; }
3252 int GetZMin() { return -1; }
3253 int GetXMax() { return -1; }
3254 int GetYMax() { return -1; }
3255 int GetZMax() { return -1; }
3256 int GetNumberButtons() { return -1; }
3257 int GetNumberAxes() { return -1; }
3258 int GetMaxButtons() { return -1; }
3259 int GetMaxAxes() { return -1; }
3260 int GetPollingMin() { return -1; }
3261 int GetPollingMax() { return -1; }
3262 int GetRudderMin() { return -1; }
3263 int GetRudderMax() { return -1; }
3264 int GetUMin() { return -1; }
3265 int GetUMax() { return -1; }
3266 int GetVMin() { return -1; }
3267 int GetVMax() { return -1; }
3268
3269 bool HasRudder() { return false; }
3270 bool HasZ() { return false; }
3271 bool HasU() { return false; }
3272 bool HasV() { return false; }
3273 bool HasPOV() { return false; }
3274 bool HasPOV4Dir() { return false; }
3275 bool HasPOVCTS() { return false; }
3276
3277 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3278 bool ReleaseCapture() { return false; }
3279 };
3280 #endif
3281
3282
3283 #include <wx/sound.h>
3284
3285
3286 #if !wxUSE_SOUND
3287 // A C++ stub class for wxWave for platforms that don't have it.
3288 class wxSound : public wxObject
3289 {
3290 public:
3291 wxSound() {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297 wxSound(const wxString&/*, bool*/) {
3298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3299 PyErr_SetString(PyExc_NotImplementedError,
3300 "wxSound is not available on this platform.");
3301 wxPyEndBlockThreads(blocked);
3302 }
3303 wxSound(int, const wxByte*) {
3304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3305 PyErr_SetString(PyExc_NotImplementedError,
3306 "wxSound is not available on this platform.");
3307 wxPyEndBlockThreads(blocked);
3308 }
3309
3310 ~wxSound() {};
3311
3312 bool Create(const wxString&/*, bool*/) { return false; }
3313 bool Create(int, const wxByte*) { return false; };
3314 bool IsOk() { return false; };
3315 bool Play(unsigned) const { return false; }
3316 static bool Play(const wxString&, unsigned) { return false; }
3317 static void Stop() {}
3318 };
3319
3320 #endif
3321
3322 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3323 if (fileName.Length() == 0)
3324 return new wxSound;
3325 else
3326 return new wxSound(fileName);
3327 }
3328 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3329 unsigned char* buffer; int size;
3330 wxSound *sound = NULL;
3331
3332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3333 if (!PyArg_Parse(data, "t#", &buffer, &size))
3334 goto done;
3335 sound = new wxSound(size, buffer);
3336 done:
3337 wxPyEndBlockThreads(blocked);
3338 return sound;
3339 }
3340 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3341 #ifndef __WXMAC__
3342 unsigned char* buffer;
3343 int size;
3344 bool rv = false;
3345
3346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3347 if (!PyArg_Parse(data, "t#", &buffer, &size))
3348 goto done;
3349 rv = self->Create(size, buffer);
3350 done:
3351 wxPyEndBlockThreads(blocked);
3352 return rv;
3353 #else
3354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3355 PyErr_SetString(PyExc_NotImplementedError,
3356 "Create from data is not available on this platform.");
3357 wxPyEndBlockThreads(blocked);
3358 return false;
3359 #endif
3360 }
3361
3362 #include <wx/mimetype.h>
3363
3364 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3365 wxString str;
3366 if (self->GetMimeType(&str))
3367 return wx2PyString(str);
3368 else
3369 RETURN_NONE();
3370 }
3371 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3372 wxArrayString arr;
3373 if (self->GetMimeTypes(arr))
3374 return wxArrayString2PyList_helper(arr);
3375 else
3376 RETURN_NONE();
3377 }
3378 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3379 wxArrayString arr;
3380 if (self->GetExtensions(arr))
3381 return wxArrayString2PyList_helper(arr);
3382 else
3383 RETURN_NONE();
3384 }
3385 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3386 wxIconLocation loc;
3387 if (self->GetIcon(&loc))
3388 return new wxIcon(loc);
3389 else
3390 return NULL;
3391 }
3392 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3393 wxIconLocation loc;
3394 if (self->GetIcon(&loc)) {
3395 wxString iconFile = loc.GetFileName();
3396 int iconIndex = -1;
3397
3398
3399
3400 // Make a tuple and put the values in it
3401 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3402 PyObject* tuple = PyTuple_New(3);
3403 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3404 wxT("wxIcon"), true));
3405 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3406 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3407 wxPyEndBlockThreads(blocked);
3408 return tuple;
3409 }
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3414 wxString str;
3415 if (self->GetDescription(&str))
3416 return wx2PyString(str);
3417 else
3418 RETURN_NONE();
3419 }
3420 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3421 wxString str;
3422 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3423 return wx2PyString(str);
3424 else
3425 RETURN_NONE();
3426 }
3427 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3428 wxString str;
3429 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3430 return wx2PyString(str);
3431 else
3432 RETURN_NONE();
3433 }
3434 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3435 wxArrayString verbs;
3436 wxArrayString commands;
3437 if (self->GetAllCommands(&verbs, &commands,
3438 wxFileType::MessageParameters(filename, mimetype))) {
3439 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3440 PyObject* tuple = PyTuple_New(2);
3441 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3442 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3443 wxPyEndBlockThreads(blocked);
3444 return tuple;
3445 }
3446 else
3447 RETURN_NONE();
3448 }
3449 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3450 return wxFileType::ExpandCommand(command,
3451 wxFileType::MessageParameters(filename, mimetype));
3452 }
3453 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3454 wxArrayString arr;
3455 self->EnumAllFileTypes(arr);
3456 return wxArrayString2PyList_helper(arr);
3457 }
3458
3459 #include <wx/artprov.h>
3460
3461 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3462 static const wxString wxPyART_MENU(wxART_MENU);
3463 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3464 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3465 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3466 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3467 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3468 static const wxString wxPyART_OTHER(wxART_OTHER);
3469 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3470 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3471 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3472 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3473 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3474 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3475 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3476 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3477 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3478 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3479 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3480 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3481 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3482 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3483 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3484 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3485 static const wxString wxPyART_PRINT(wxART_PRINT);
3486 static const wxString wxPyART_HELP(wxART_HELP);
3487 static const wxString wxPyART_TIP(wxART_TIP);
3488 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3489 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3490 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3491 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3492 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3493 static const wxString wxPyART_CDROM(wxART_CDROM);
3494 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3495 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3496 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3497 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3498 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3499 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3500 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3501 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3502 static const wxString wxPyART_ERROR(wxART_ERROR);
3503 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3504 static const wxString wxPyART_WARNING(wxART_WARNING);
3505 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3506 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3507 static const wxString wxPyART_COPY(wxART_COPY);
3508 static const wxString wxPyART_CUT(wxART_CUT);
3509 static const wxString wxPyART_PASTE(wxART_PASTE);
3510 static const wxString wxPyART_DELETE(wxART_DELETE);
3511 static const wxString wxPyART_NEW(wxART_NEW);
3512 static const wxString wxPyART_UNDO(wxART_UNDO);
3513 static const wxString wxPyART_REDO(wxART_REDO);
3514 static const wxString wxPyART_QUIT(wxART_QUIT);
3515 static const wxString wxPyART_FIND(wxART_FIND);
3516 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3517 // Python aware wxArtProvider
3518 class wxPyArtProvider : public wxArtProvider {
3519 public:
3520
3521 virtual wxBitmap CreateBitmap(const wxArtID& id,
3522 const wxArtClient& client,
3523 const wxSize& size) {
3524 wxBitmap rval = wxNullBitmap;
3525 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3526 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3527 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3528 PyObject* ro;
3529 wxBitmap* ptr;
3530 PyObject* s1, *s2;
3531 s1 = wx2PyString(id);
3532 s2 = wx2PyString(client);
3533 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3534 Py_DECREF(so);
3535 Py_DECREF(s1);
3536 Py_DECREF(s2);
3537 if (ro) {
3538 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3539 rval = *ptr;
3540 Py_DECREF(ro);
3541 }
3542 }
3543 wxPyEndBlockThreads(blocked);
3544 return rval;
3545 }
3546
3547 PYPRIVATE;
3548 };
3549
3550 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3551
3552
3553
3554 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3555 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3556 PyObject* ret = PyTuple_New(3);
3557 if (ret) {
3558 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3559 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3560 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3561 }
3562 wxPyEndBlockThreads(blocked);
3563 return ret;
3564 }
3565
3566 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3567 bool cont;
3568 long index = 0;
3569 wxString value;
3570
3571 cont = self->GetFirstGroup(value, index);
3572 return __EnumerationHelper(cont, value, index);
3573 }
3574 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3575 bool cont;
3576 wxString value;
3577
3578 cont = self->GetNextGroup(value, index);
3579 return __EnumerationHelper(cont, value, index);
3580 }
3581 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3582 bool cont;
3583 long index = 0;
3584 wxString value;
3585
3586 cont = self->GetFirstEntry(value, index);
3587 return __EnumerationHelper(cont, value, index);
3588 }
3589 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3590 bool cont;
3591 wxString value;
3592
3593 cont = self->GetNextEntry(value, index);
3594 return __EnumerationHelper(cont, value, index);
3595 }
3596 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3597 long rv;
3598 self->Read(key, &rv, defaultVal);
3599 return rv;
3600 }
3601
3602 SWIGINTERN int
3603 SWIG_AsVal_double (PyObject *obj, double* val)
3604 {
3605 if (PyNumber_Check(obj)) {
3606 if (val) *val = PyFloat_AsDouble(obj);
3607 return SWIG_OK;
3608 }
3609 return SWIG_TypeError;
3610 }
3611
3612 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3613 double rv;
3614 self->Read(key, &rv, defaultVal);
3615 return rv;
3616 }
3617
3618 #define SWIG_From_double PyFloat_FromDouble
3619
3620 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3621 bool rv;
3622 self->Read(key, &rv, defaultVal);
3623 return rv;
3624 }
3625
3626 #include <wx/datetime.h>
3627
3628 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3629 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3630
3631 #define LOCAL_TZ wxDateTime::Local
3632
3633 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3634 wxString am;
3635 wxString pm;
3636 wxDateTime::GetAmPmStrings(&am, &pm);
3637 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3638 PyObject* tup = PyTuple_New(2);
3639 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3640 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3641 wxPyEndBlockThreads(blocked);
3642 return tup;
3643 }
3644
3645 SWIGINTERNINLINE PyObject *
3646 SWIG_From_unsigned_SS_int (unsigned int value)
3647 {
3648 return SWIG_From_unsigned_SS_long (value);
3649 }
3650
3651 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3652 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3653 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3654 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3655 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3656 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3657 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3658 return (*self < *other);
3659 }
3660 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3661 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3662 return (*self <= *other);
3663 }
3664 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3665 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3666 return (*self > *other);
3667 }
3668 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3669 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3670 return (*self >= *other);
3671 }
3672 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3673 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3674 return (*self == *other);
3675 }
3676 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3677 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3678 return (*self != *other);
3679 }
3680 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3681 const wxChar* rv;
3682 const wxChar* _date = date;
3683 rv = self->ParseRfc822Date(_date);
3684 if (rv == NULL) return -1;
3685 return rv - _date;
3686 }
3687 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3688 const wxChar* rv;
3689 const wxChar* _date = date;
3690 rv = self->ParseFormat(_date, format, dateDef);
3691 if (rv == NULL) return -1;
3692 return rv - _date;
3693 }
3694 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3695 const wxChar* rv;
3696 const wxChar* _datetime = datetime;
3697 rv = self->ParseDateTime(_datetime);
3698 if (rv == NULL) return -1;
3699 return rv - _datetime;
3700 }
3701 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3702 const wxChar* rv;
3703 const wxChar* _date = date;
3704 rv = self->ParseDate(_date);
3705 if (rv == NULL) return -1;
3706 return rv - _date;
3707 }
3708 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3709 const wxChar* rv;
3710 const wxChar* _time = time;
3711 rv = self->ParseTime(_time);
3712 if (rv == NULL) return -1;
3713 return rv - _time;
3714 }
3715 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3716 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3717 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3718 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3719 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3720 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3721 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3722 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3723 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3724 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3725 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3726 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3727 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3728 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3729 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3730 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3731
3732 #include <wx/dataobj.h>
3733
3734 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3735 size_t count = self->GetFormatCount(dir);
3736 wxDataFormat* formats = new wxDataFormat[count];
3737 self->GetAllFormats(formats, dir);
3738
3739 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3740 PyObject* list = PyList_New(count);
3741 for (size_t i=0; i<count; i++) {
3742 wxDataFormat* format = new wxDataFormat(formats[i]);
3743 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3744 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3745 }
3746 wxPyEndBlockThreads(blocked);
3747 delete [] formats;
3748 return list;
3749 }
3750 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3751 PyObject* rval = NULL;
3752 size_t size = self->GetDataSize(format);
3753 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3754 if (size) {
3755 char* buf = new char[size];
3756 if (self->GetDataHere(format, buf))
3757 rval = PyString_FromStringAndSize(buf, size);
3758 delete [] buf;
3759 }
3760 if (! rval) {
3761 rval = Py_None;
3762 Py_INCREF(rval);
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return rval;
3766 }
3767 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3768 bool rval;
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 if (PyString_Check(data)) {
3771 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3772 }
3773 else {
3774 // raise a TypeError if not a string
3775 PyErr_SetString(PyExc_TypeError, "String expected.");
3776 rval = false;
3777 }
3778 wxPyEndBlockThreads(blocked);
3779 return rval;
3780 }
3781 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3782 PyObject* rval = NULL;
3783 size_t size = self->GetDataSize();
3784 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3785 if (size) {
3786 char* buf = new char[size];
3787 if (self->GetDataHere(buf))
3788 rval = PyString_FromStringAndSize(buf, size);
3789 delete [] buf;
3790 }
3791 if (! rval) {
3792 rval = Py_None;
3793 Py_INCREF(rval);
3794 }
3795 wxPyEndBlockThreads(blocked);
3796 return rval;
3797 }
3798 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3799 bool rval;
3800 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3801 if (PyString_Check(data)) {
3802 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3803 }
3804 else {
3805 // raise a TypeError if not a string
3806 PyErr_SetString(PyExc_TypeError, "String expected.");
3807 rval = false;
3808 }
3809 wxPyEndBlockThreads(blocked);
3810 return rval;
3811 }
3812 // Create a new class for wxPython to use
3813 class wxPyDataObjectSimple : public wxDataObjectSimple {
3814 public:
3815 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3816 : wxDataObjectSimple(format) {}
3817
3818 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3819 bool GetDataHere(void *buf) const;
3820 bool SetData(size_t len, const void *buf);
3821 PYPRIVATE;
3822 };
3823
3824 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3825
3826 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3827 // We need to get the data for this object and write it to buf. I think
3828 // the best way to do this for wxPython is to have the Python method
3829 // return either a string or None and then act appropriately with the
3830 // C++ version.
3831
3832 bool rval = false;
3833 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3834 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3835 PyObject* ro;
3836 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3837 if (ro) {
3838 rval = (ro != Py_None && PyString_Check(ro));
3839 if (rval)
3840 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3841 Py_DECREF(ro);
3842 }
3843 }
3844 wxPyEndBlockThreads(blocked);
3845 return rval;
3846 }
3847
3848 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3849 // For this one we simply need to make a string from buf and len
3850 // and send it to the Python method.
3851 bool rval = false;
3852 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3853 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3854 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3855 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3856 Py_DECREF(data);
3857 }
3858 wxPyEndBlockThreads(blocked);
3859 return rval;
3860 }
3861
3862 // Create a new class for wxPython to use
3863 class wxPyTextDataObject : public wxTextDataObject {
3864 public:
3865 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3866 : wxTextDataObject(text) {}
3867
3868 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3869 DEC_PYCALLBACK_STRING__const(GetText);
3870 DEC_PYCALLBACK__STRING(SetText);
3871 PYPRIVATE;
3872 };
3873
3874 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3875 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3876 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3877
3878
3879 // Create a new class for wxPython to use
3880 class wxPyBitmapDataObject : public wxBitmapDataObject {
3881 public:
3882 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3883 : wxBitmapDataObject(bitmap) {}
3884
3885 wxBitmap GetBitmap() const;
3886 void SetBitmap(const wxBitmap& bitmap);
3887 PYPRIVATE;
3888 };
3889
3890 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3891 wxBitmap* rval = &wxNullBitmap;
3892 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3893 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3894 PyObject* ro;
3895 wxBitmap* ptr;
3896 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3897 if (ro) {
3898 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3899 rval = ptr;
3900 Py_DECREF(ro);
3901 }
3902 }
3903 wxPyEndBlockThreads(blocked);
3904 return *rval;
3905 }
3906
3907 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3908 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3909 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3910 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3911 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3912 Py_DECREF(bo);
3913 }
3914 wxPyEndBlockThreads(blocked);
3915 }
3916
3917 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3918 return new wxCustomDataObject(wxDataFormat(formatName));
3919 }
3920 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3921 bool rval;
3922 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3923 if (PyString_Check(data)) {
3924 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3925 }
3926 else {
3927 // raise a TypeError if not a string
3928 PyErr_SetString(PyExc_TypeError, "String expected.");
3929 rval = false;
3930 }
3931 wxPyEndBlockThreads(blocked);
3932 return rval;
3933 }
3934 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3935 PyObject* obj;
3936 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3937 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3938 wxPyEndBlockThreads(blocked);
3939 return obj;
3940 }
3941
3942 class wxMetafileDataObject : public wxDataObjectSimple
3943 {
3944 public:
3945 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3946 };
3947
3948
3949 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3950
3951
3952 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3953 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3954 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3955 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3956 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3957
3958
3959 class wxPyTextDropTarget : public wxTextDropTarget {
3960 public:
3961 wxPyTextDropTarget() {}
3962
3963 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3964
3965 DEC_PYCALLBACK__(OnLeave);
3966 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3967 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3968 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3969 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3970
3971 PYPRIVATE;
3972 };
3973
3974 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3975 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3976 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3977 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3978 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3979 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3980
3981
3982
3983 class wxPyFileDropTarget : public wxFileDropTarget {
3984 public:
3985 wxPyFileDropTarget() {}
3986
3987 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3988
3989 DEC_PYCALLBACK__(OnLeave);
3990 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3991 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3992 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3993 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3994
3995 PYPRIVATE;
3996 };
3997
3998 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3999 const wxArrayString& filenames) {
4000 bool rval = false;
4001 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4002 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
4003 PyObject* list = wxArrayString2PyList_helper(filenames);
4004 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
4005 Py_DECREF(list);
4006 }
4007 wxPyEndBlockThreads(blocked);
4008 return rval;
4009 }
4010
4011
4012
4013 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4014 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4015 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4016 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4017 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4018
4019
4020
4021
4022 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4023
4024 #include <wx/display.h>
4025 #include <wx/vidmode.h>
4026
4027 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4028 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4029
4030 #if !wxUSE_DISPLAY
4031 const wxVideoMode wxDefaultVideoMode;
4032 #endif
4033
4034 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4035 #if wxUSE_DISPLAY
4036 PyObject* pyList = NULL;
4037 wxArrayVideoModes arr = self->GetModes(mode);
4038 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4039 pyList = PyList_New(0);
4040 for (size_t i=0; i < arr.GetCount(); i++)
4041 {
4042 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4043 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4044 PyList_Append(pyList, pyObj);
4045 Py_DECREF(pyObj);
4046 }
4047 wxPyEndBlockThreads(blocked);
4048 return pyList;
4049 #else
4050 wxPyRaiseNotImplemented();
4051 return NULL;
4052 #endif
4053 }
4054 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4055 #if wxUSE_DISPLAY
4056 return self->GetCurrentMode();
4057 #else
4058 wxPyRaiseNotImplemented();
4059 return wxDefaultVideoMode;
4060 #endif
4061 }
4062 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4063 #if wxUSE_DISPLAY
4064 return self->ChangeMode(mode);
4065 #else
4066 wxPyRaiseNotImplemented();
4067 return false;
4068 #endif
4069 }
4070 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4071 #if wxUSE_DISPLAY
4072 self->ResetMode();
4073 #else
4074 wxPyRaiseNotImplemented();
4075 #endif
4076 }
4077
4078 #include <wx/stdpaths.h>
4079
4080 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4081 return (wxStandardPaths*) &wxStandardPaths::Get();
4082 }
4083
4084 #ifndef wxHAS_POWER_EVENTS
4085 // Dummy class and other definitions for platforms that don't have them
4086
4087 // See wxPython_int.h for wxPowerEvent
4088
4089 enum {
4090 wxEVT_POWER_SUSPENDING,
4091 wxEVT_POWER_SUSPENDED,
4092 wxEVT_POWER_SUSPEND_CANCEL,
4093 wxEVT_POWER_RESUME,
4094 };
4095
4096 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4097 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4098
4099 #endif
4100
4101
4102 #include <wx/aboutdlg.h>
4103
4104 #ifdef __cplusplus
4105 extern "C" {
4106 #endif
4107 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4108 PyObject *resultobj = 0;
4109 wxSystemColour arg1 ;
4110 wxColour result;
4111 int val1 ;
4112 int ecode1 = 0 ;
4113 PyObject * obj0 = 0 ;
4114 char * kwnames[] = {
4115 (char *) "index", NULL
4116 };
4117
4118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4119 ecode1 = SWIG_AsVal_int(obj0, &val1);
4120 if (!SWIG_IsOK(ecode1)) {
4121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4122 }
4123 arg1 = static_cast< wxSystemColour >(val1);
4124 {
4125 if (!wxPyCheckForApp()) SWIG_fail;
4126 PyThreadState* __tstate = wxPyBeginAllowThreads();
4127 result = wxSystemSettings::GetColour(arg1);
4128 wxPyEndAllowThreads(__tstate);
4129 if (PyErr_Occurred()) SWIG_fail;
4130 }
4131 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4132 return resultobj;
4133 fail:
4134 return NULL;
4135 }
4136
4137
4138 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4139 PyObject *resultobj = 0;
4140 wxSystemFont arg1 ;
4141 wxFont result;
4142 int val1 ;
4143 int ecode1 = 0 ;
4144 PyObject * obj0 = 0 ;
4145 char * kwnames[] = {
4146 (char *) "index", NULL
4147 };
4148
4149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4150 ecode1 = SWIG_AsVal_int(obj0, &val1);
4151 if (!SWIG_IsOK(ecode1)) {
4152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4153 }
4154 arg1 = static_cast< wxSystemFont >(val1);
4155 {
4156 if (!wxPyCheckForApp()) SWIG_fail;
4157 PyThreadState* __tstate = wxPyBeginAllowThreads();
4158 result = wxSystemSettings::GetFont(arg1);
4159 wxPyEndAllowThreads(__tstate);
4160 if (PyErr_Occurred()) SWIG_fail;
4161 }
4162 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4163 return resultobj;
4164 fail:
4165 return NULL;
4166 }
4167
4168
4169 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4170 PyObject *resultobj = 0;
4171 wxSystemMetric arg1 ;
4172 wxWindow *arg2 = (wxWindow *) NULL ;
4173 int result;
4174 int val1 ;
4175 int ecode1 = 0 ;
4176 void *argp2 = 0 ;
4177 int res2 = 0 ;
4178 PyObject * obj0 = 0 ;
4179 PyObject * obj1 = 0 ;
4180 char * kwnames[] = {
4181 (char *) "index",(char *) "win", NULL
4182 };
4183
4184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4185 ecode1 = SWIG_AsVal_int(obj0, &val1);
4186 if (!SWIG_IsOK(ecode1)) {
4187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4188 }
4189 arg1 = static_cast< wxSystemMetric >(val1);
4190 if (obj1) {
4191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4192 if (!SWIG_IsOK(res2)) {
4193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4194 }
4195 arg2 = reinterpret_cast< wxWindow * >(argp2);
4196 }
4197 {
4198 if (!wxPyCheckForApp()) SWIG_fail;
4199 PyThreadState* __tstate = wxPyBeginAllowThreads();
4200 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4201 wxPyEndAllowThreads(__tstate);
4202 if (PyErr_Occurred()) SWIG_fail;
4203 }
4204 resultobj = SWIG_From_int(static_cast< int >(result));
4205 return resultobj;
4206 fail:
4207 return NULL;
4208 }
4209
4210
4211 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4212 PyObject *resultobj = 0;
4213 wxSystemFeature arg1 ;
4214 bool result;
4215 int val1 ;
4216 int ecode1 = 0 ;
4217 PyObject * obj0 = 0 ;
4218 char * kwnames[] = {
4219 (char *) "index", NULL
4220 };
4221
4222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4223 ecode1 = SWIG_AsVal_int(obj0, &val1);
4224 if (!SWIG_IsOK(ecode1)) {
4225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4226 }
4227 arg1 = static_cast< wxSystemFeature >(val1);
4228 {
4229 if (!wxPyCheckForApp()) SWIG_fail;
4230 PyThreadState* __tstate = wxPyBeginAllowThreads();
4231 result = (bool)wxSystemSettings::HasFeature(arg1);
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 {
4236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4237 }
4238 return resultobj;
4239 fail:
4240 return NULL;
4241 }
4242
4243
4244 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4245 PyObject *resultobj = 0;
4246 wxSystemScreenType result;
4247
4248 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4249 {
4250 if (!wxPyCheckForApp()) SWIG_fail;
4251 PyThreadState* __tstate = wxPyBeginAllowThreads();
4252 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4253 wxPyEndAllowThreads(__tstate);
4254 if (PyErr_Occurred()) SWIG_fail;
4255 }
4256 resultobj = SWIG_From_int(static_cast< int >(result));
4257 return resultobj;
4258 fail:
4259 return NULL;
4260 }
4261
4262
4263 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4264 PyObject *resultobj = 0;
4265 wxSystemScreenType arg1 ;
4266 int val1 ;
4267 int ecode1 = 0 ;
4268 PyObject * obj0 = 0 ;
4269 char * kwnames[] = {
4270 (char *) "screen", NULL
4271 };
4272
4273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4274 ecode1 = SWIG_AsVal_int(obj0, &val1);
4275 if (!SWIG_IsOK(ecode1)) {
4276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4277 }
4278 arg1 = static_cast< wxSystemScreenType >(val1);
4279 {
4280 if (!wxPyCheckForApp()) SWIG_fail;
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 wxSystemSettings::SetScreenType(arg1);
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 resultobj = SWIG_Py_Void();
4287 return resultobj;
4288 fail:
4289 return NULL;
4290 }
4291
4292
4293 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4294 PyObject *obj;
4295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4296 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4297 return SWIG_Py_Void();
4298 }
4299
4300 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4301 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4302 return 1;
4303 }
4304
4305
4306 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4307 PyObject *pyobj = 0;
4308
4309 {
4310 #if wxUSE_UNICODE
4311 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4312 #else
4313 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4314 #endif
4315 }
4316 return pyobj;
4317 }
4318
4319
4320 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4321 PyObject *resultobj = 0;
4322 wxSystemOptions *result = 0 ;
4323
4324 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4325 {
4326 PyThreadState* __tstate = wxPyBeginAllowThreads();
4327 result = (wxSystemOptions *)new wxSystemOptions();
4328 wxPyEndAllowThreads(__tstate);
4329 if (PyErr_Occurred()) SWIG_fail;
4330 }
4331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4332 return resultobj;
4333 fail:
4334 return NULL;
4335 }
4336
4337
4338 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4339 PyObject *resultobj = 0;
4340 wxString *arg1 = 0 ;
4341 wxString *arg2 = 0 ;
4342 bool temp1 = false ;
4343 bool temp2 = false ;
4344 PyObject * obj0 = 0 ;
4345 PyObject * obj1 = 0 ;
4346 char * kwnames[] = {
4347 (char *) "name",(char *) "value", NULL
4348 };
4349
4350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4351 {
4352 arg1 = wxString_in_helper(obj0);
4353 if (arg1 == NULL) SWIG_fail;
4354 temp1 = true;
4355 }
4356 {
4357 arg2 = wxString_in_helper(obj1);
4358 if (arg2 == NULL) SWIG_fail;
4359 temp2 = true;
4360 }
4361 {
4362 PyThreadState* __tstate = wxPyBeginAllowThreads();
4363 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4364 wxPyEndAllowThreads(__tstate);
4365 if (PyErr_Occurred()) SWIG_fail;
4366 }
4367 resultobj = SWIG_Py_Void();
4368 {
4369 if (temp1)
4370 delete arg1;
4371 }
4372 {
4373 if (temp2)
4374 delete arg2;
4375 }
4376 return resultobj;
4377 fail:
4378 {
4379 if (temp1)
4380 delete arg1;
4381 }
4382 {
4383 if (temp2)
4384 delete arg2;
4385 }
4386 return NULL;
4387 }
4388
4389
4390 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4391 PyObject *resultobj = 0;
4392 wxString *arg1 = 0 ;
4393 int arg2 ;
4394 bool temp1 = false ;
4395 int val2 ;
4396 int ecode2 = 0 ;
4397 PyObject * obj0 = 0 ;
4398 PyObject * obj1 = 0 ;
4399 char * kwnames[] = {
4400 (char *) "name",(char *) "value", NULL
4401 };
4402
4403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4404 {
4405 arg1 = wxString_in_helper(obj0);
4406 if (arg1 == NULL) SWIG_fail;
4407 temp1 = true;
4408 }
4409 ecode2 = SWIG_AsVal_int(obj1, &val2);
4410 if (!SWIG_IsOK(ecode2)) {
4411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4412 }
4413 arg2 = static_cast< int >(val2);
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 resultobj = SWIG_Py_Void();
4421 {
4422 if (temp1)
4423 delete arg1;
4424 }
4425 return resultobj;
4426 fail:
4427 {
4428 if (temp1)
4429 delete arg1;
4430 }
4431 return NULL;
4432 }
4433
4434
4435 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj = 0;
4437 wxString *arg1 = 0 ;
4438 wxString result;
4439 bool temp1 = false ;
4440 PyObject * obj0 = 0 ;
4441 char * kwnames[] = {
4442 (char *) "name", NULL
4443 };
4444
4445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4446 {
4447 arg1 = wxString_in_helper(obj0);
4448 if (arg1 == NULL) SWIG_fail;
4449 temp1 = true;
4450 }
4451 {
4452 PyThreadState* __tstate = wxPyBeginAllowThreads();
4453 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4454 wxPyEndAllowThreads(__tstate);
4455 if (PyErr_Occurred()) SWIG_fail;
4456 }
4457 {
4458 #if wxUSE_UNICODE
4459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4460 #else
4461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4462 #endif
4463 }
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return resultobj;
4469 fail:
4470 {
4471 if (temp1)
4472 delete arg1;
4473 }
4474 return NULL;
4475 }
4476
4477
4478 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4479 PyObject *resultobj = 0;
4480 wxString *arg1 = 0 ;
4481 int result;
4482 bool temp1 = false ;
4483 PyObject * obj0 = 0 ;
4484 char * kwnames[] = {
4485 (char *) "name", NULL
4486 };
4487
4488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4489 {
4490 arg1 = wxString_in_helper(obj0);
4491 if (arg1 == NULL) SWIG_fail;
4492 temp1 = true;
4493 }
4494 {
4495 PyThreadState* __tstate = wxPyBeginAllowThreads();
4496 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4497 wxPyEndAllowThreads(__tstate);
4498 if (PyErr_Occurred()) SWIG_fail;
4499 }
4500 resultobj = SWIG_From_int(static_cast< int >(result));
4501 {
4502 if (temp1)
4503 delete arg1;
4504 }
4505 return resultobj;
4506 fail:
4507 {
4508 if (temp1)
4509 delete arg1;
4510 }
4511 return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4516 PyObject *resultobj = 0;
4517 wxString *arg1 = 0 ;
4518 bool result;
4519 bool temp1 = false ;
4520 PyObject * obj0 = 0 ;
4521 char * kwnames[] = {
4522 (char *) "name", NULL
4523 };
4524
4525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4526 {
4527 arg1 = wxString_in_helper(obj0);
4528 if (arg1 == NULL) SWIG_fail;
4529 temp1 = true;
4530 }
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4539 }
4540 {
4541 if (temp1)
4542 delete arg1;
4543 }
4544 return resultobj;
4545 fail:
4546 {
4547 if (temp1)
4548 delete arg1;
4549 }
4550 return NULL;
4551 }
4552
4553
4554 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4555 PyObject *resultobj = 0;
4556 wxString *arg1 = 0 ;
4557 bool result;
4558 bool temp1 = false ;
4559 PyObject * obj0 = 0 ;
4560 char * kwnames[] = {
4561 (char *) "name", NULL
4562 };
4563
4564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4565 {
4566 arg1 = wxString_in_helper(obj0);
4567 if (arg1 == NULL) SWIG_fail;
4568 temp1 = true;
4569 }
4570 {
4571 PyThreadState* __tstate = wxPyBeginAllowThreads();
4572 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4573 wxPyEndAllowThreads(__tstate);
4574 if (PyErr_Occurred()) SWIG_fail;
4575 }
4576 {
4577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4578 }
4579 {
4580 if (temp1)
4581 delete arg1;
4582 }
4583 return resultobj;
4584 fail:
4585 {
4586 if (temp1)
4587 delete arg1;
4588 }
4589 return NULL;
4590 }
4591
4592
4593 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4594 PyObject *obj;
4595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4596 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4597 return SWIG_Py_Void();
4598 }
4599
4600 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4601 return SWIG_Python_InitShadowInstance(args);
4602 }
4603
4604 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4605 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4606 return 1;
4607 }
4608
4609
4610 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4611 PyObject *pyobj = 0;
4612
4613 {
4614 #if wxUSE_UNICODE
4615 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4616 #else
4617 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4618 #endif
4619 }
4620 return pyobj;
4621 }
4622
4623
4624 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4625 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4626 return 1;
4627 }
4628
4629
4630 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4631 PyObject *pyobj = 0;
4632
4633 {
4634 #if wxUSE_UNICODE
4635 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4636 #else
4637 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4638 #endif
4639 }
4640 return pyobj;
4641 }
4642
4643
4644 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4645 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4646 return 1;
4647 }
4648
4649
4650 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4651 PyObject *pyobj = 0;
4652
4653 {
4654 #if wxUSE_UNICODE
4655 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4656 #else
4657 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4658 #endif
4659 }
4660 return pyobj;
4661 }
4662
4663
4664 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4665 PyObject *resultobj = 0;
4666 long result;
4667
4668 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4669 {
4670 PyThreadState* __tstate = wxPyBeginAllowThreads();
4671 result = (long)wxNewId();
4672 wxPyEndAllowThreads(__tstate);
4673 if (PyErr_Occurred()) SWIG_fail;
4674 }
4675 resultobj = SWIG_From_long(static_cast< long >(result));
4676 return resultobj;
4677 fail:
4678 return NULL;
4679 }
4680
4681
4682 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4683 PyObject *resultobj = 0;
4684 long arg1 ;
4685 long val1 ;
4686 int ecode1 = 0 ;
4687 PyObject * obj0 = 0 ;
4688 char * kwnames[] = {
4689 (char *) "id", NULL
4690 };
4691
4692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4693 ecode1 = SWIG_AsVal_long(obj0, &val1);
4694 if (!SWIG_IsOK(ecode1)) {
4695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4696 }
4697 arg1 = static_cast< long >(val1);
4698 {
4699 PyThreadState* __tstate = wxPyBeginAllowThreads();
4700 wxRegisterId(arg1);
4701 wxPyEndAllowThreads(__tstate);
4702 if (PyErr_Occurred()) SWIG_fail;
4703 }
4704 resultobj = SWIG_Py_Void();
4705 return resultobj;
4706 fail:
4707 return NULL;
4708 }
4709
4710
4711 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4712 PyObject *resultobj = 0;
4713 long result;
4714
4715 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = (long)wxGetCurrentId();
4719 wxPyEndAllowThreads(__tstate);
4720 if (PyErr_Occurred()) SWIG_fail;
4721 }
4722 resultobj = SWIG_From_long(static_cast< long >(result));
4723 return resultobj;
4724 fail:
4725 return NULL;
4726 }
4727
4728
4729 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4730 PyObject *resultobj = 0;
4731 int arg1 ;
4732 bool result;
4733 int val1 ;
4734 int ecode1 = 0 ;
4735 PyObject * obj0 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "id", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4741 ecode1 = SWIG_AsVal_int(obj0, &val1);
4742 if (!SWIG_IsOK(ecode1)) {
4743 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4744 }
4745 arg1 = static_cast< int >(val1);
4746 {
4747 PyThreadState* __tstate = wxPyBeginAllowThreads();
4748 result = (bool)wxIsStockID(arg1);
4749 wxPyEndAllowThreads(__tstate);
4750 if (PyErr_Occurred()) SWIG_fail;
4751 }
4752 {
4753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4754 }
4755 return resultobj;
4756 fail:
4757 return NULL;
4758 }
4759
4760
4761 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4762 PyObject *resultobj = 0;
4763 int arg1 ;
4764 wxString *arg2 = 0 ;
4765 bool result;
4766 int val1 ;
4767 int ecode1 = 0 ;
4768 bool temp2 = false ;
4769 PyObject * obj0 = 0 ;
4770 PyObject * obj1 = 0 ;
4771 char * kwnames[] = {
4772 (char *) "id",(char *) "label", NULL
4773 };
4774
4775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4776 ecode1 = SWIG_AsVal_int(obj0, &val1);
4777 if (!SWIG_IsOK(ecode1)) {
4778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4779 }
4780 arg1 = static_cast< int >(val1);
4781 {
4782 arg2 = wxString_in_helper(obj1);
4783 if (arg2 == NULL) SWIG_fail;
4784 temp2 = true;
4785 }
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 {
4793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4794 }
4795 {
4796 if (temp2)
4797 delete arg2;
4798 }
4799 return resultobj;
4800 fail:
4801 {
4802 if (temp2)
4803 delete arg2;
4804 }
4805 return NULL;
4806 }
4807
4808
4809 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = 0;
4811 int arg1 ;
4812 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4813 wxString result;
4814 int val1 ;
4815 int ecode1 = 0 ;
4816 long val2 ;
4817 int ecode2 = 0 ;
4818 PyObject * obj0 = 0 ;
4819 PyObject * obj1 = 0 ;
4820 char * kwnames[] = {
4821 (char *) "id",(char *) "flags", NULL
4822 };
4823
4824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4825 ecode1 = SWIG_AsVal_int(obj0, &val1);
4826 if (!SWIG_IsOK(ecode1)) {
4827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4828 }
4829 arg1 = static_cast< int >(val1);
4830 if (obj1) {
4831 ecode2 = SWIG_AsVal_long(obj1, &val2);
4832 if (!SWIG_IsOK(ecode2)) {
4833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4834 }
4835 arg2 = static_cast< long >(val2);
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 result = wxGetStockLabel(arg1,arg2);
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 {
4844 #if wxUSE_UNICODE
4845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4846 #else
4847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4848 #endif
4849 }
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj = 0;
4858 int arg1 ;
4859 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4860 wxString result;
4861 int val1 ;
4862 int ecode1 = 0 ;
4863 int val2 ;
4864 int ecode2 = 0 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 char * kwnames[] = {
4868 (char *) "id",(char *) "client", NULL
4869 };
4870
4871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4872 ecode1 = SWIG_AsVal_int(obj0, &val1);
4873 if (!SWIG_IsOK(ecode1)) {
4874 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4875 }
4876 arg1 = static_cast< int >(val1);
4877 if (obj1) {
4878 ecode2 = SWIG_AsVal_int(obj1, &val2);
4879 if (!SWIG_IsOK(ecode2)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4881 }
4882 arg2 = static_cast< wxStockHelpStringClient >(val2);
4883 }
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 result = wxGetStockHelpString(arg1,arg2);
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 {
4891 #if wxUSE_UNICODE
4892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4893 #else
4894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4895 #endif
4896 }
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4904 PyObject *resultobj = 0;
4905
4906 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4907 {
4908 if (!wxPyCheckForApp()) SWIG_fail;
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 wxBell();
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_Py_Void();
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4922 PyObject *resultobj = 0;
4923
4924 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4925 {
4926 if (!wxPyCheckForApp()) SWIG_fail;
4927 PyThreadState* __tstate = wxPyBeginAllowThreads();
4928 wxEndBusyCursor();
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 resultobj = SWIG_Py_Void();
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj = 0;
4941 bool arg1 = (bool) true ;
4942 long result;
4943 bool val1 ;
4944 int ecode1 = 0 ;
4945 PyObject * obj0 = 0 ;
4946 char * kwnames[] = {
4947 (char *) "resetTimer", NULL
4948 };
4949
4950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4951 if (obj0) {
4952 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4953 if (!SWIG_IsOK(ecode1)) {
4954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4955 }
4956 arg1 = static_cast< bool >(val1);
4957 }
4958 {
4959 PyThreadState* __tstate = wxPyBeginAllowThreads();
4960 result = (long)wxGetElapsedTime(arg1);
4961 wxPyEndAllowThreads(__tstate);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 resultobj = SWIG_From_long(static_cast< long >(result));
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4972 PyObject *resultobj = 0;
4973 bool result;
4974
4975 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4976 {
4977 PyThreadState* __tstate = wxPyBeginAllowThreads();
4978 result = (bool)wxIsBusy();
4979 wxPyEndAllowThreads(__tstate);
4980 if (PyErr_Occurred()) SWIG_fail;
4981 }
4982 {
4983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4984 }
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4992 PyObject *resultobj = 0;
4993 wxString result;
4994
4995 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4996 {
4997 PyThreadState* __tstate = wxPyBeginAllowThreads();
4998 result = wxNow();
4999 wxPyEndAllowThreads(__tstate);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 {
5003 #if wxUSE_UNICODE
5004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5005 #else
5006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5007 #endif
5008 }
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5016 PyObject *resultobj = 0;
5017 wxString const &arg1_defvalue = wxPyEmptyString ;
5018 wxString *arg1 = (wxString *) &arg1_defvalue ;
5019 bool result;
5020 bool temp1 = false ;
5021 PyObject * obj0 = 0 ;
5022 char * kwnames[] = {
5023 (char *) "command", NULL
5024 };
5025
5026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5027 if (obj0) {
5028 {
5029 arg1 = wxString_in_helper(obj0);
5030 if (arg1 == NULL) SWIG_fail;
5031 temp1 = true;
5032 }
5033 }
5034 {
5035 PyThreadState* __tstate = wxPyBeginAllowThreads();
5036 result = (bool)wxShell((wxString const &)*arg1);
5037 wxPyEndAllowThreads(__tstate);
5038 if (PyErr_Occurred()) SWIG_fail;
5039 }
5040 {
5041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5042 }
5043 {
5044 if (temp1)
5045 delete arg1;
5046 }
5047 return resultobj;
5048 fail:
5049 {
5050 if (temp1)
5051 delete arg1;
5052 }
5053 return NULL;
5054 }
5055
5056
5057 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5058 PyObject *resultobj = 0;
5059
5060 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5061 {
5062 PyThreadState* __tstate = wxPyBeginAllowThreads();
5063 wxStartTimer();
5064 wxPyEndAllowThreads(__tstate);
5065 if (PyErr_Occurred()) SWIG_fail;
5066 }
5067 resultobj = SWIG_Py_Void();
5068 return resultobj;
5069 fail:
5070 return NULL;
5071 }
5072
5073
5074 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5075 PyObject *resultobj = 0;
5076 int *arg1 = (int *) 0 ;
5077 int *arg2 = (int *) 0 ;
5078 int result;
5079 int temp1 ;
5080 int res1 = SWIG_TMPOBJ ;
5081 int temp2 ;
5082 int res2 = SWIG_TMPOBJ ;
5083
5084 arg1 = &temp1;
5085 arg2 = &temp2;
5086 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5087 {
5088 PyThreadState* __tstate = wxPyBeginAllowThreads();
5089 result = (int)wxGetOsVersion(arg1,arg2);
5090 wxPyEndAllowThreads(__tstate);
5091 if (PyErr_Occurred()) SWIG_fail;
5092 }
5093 resultobj = SWIG_From_int(static_cast< int >(result));
5094 if (SWIG_IsTmpObj(res1)) {
5095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5096 } else {
5097 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5099 }
5100 if (SWIG_IsTmpObj(res2)) {
5101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5102 } else {
5103 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5105 }
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5113 PyObject *resultobj = 0;
5114 wxString result;
5115
5116 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5117 {
5118 PyThreadState* __tstate = wxPyBeginAllowThreads();
5119 result = wxGetOsDescription();
5120 wxPyEndAllowThreads(__tstate);
5121 if (PyErr_Occurred()) SWIG_fail;
5122 }
5123 {
5124 #if wxUSE_UNICODE
5125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5126 #else
5127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5128 #endif
5129 }
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 bool result;
5139
5140 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5141 {
5142 PyThreadState* __tstate = wxPyBeginAllowThreads();
5143 result = (bool)wxIsPlatformLittleEndian();
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 {
5148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5149 }
5150 return resultobj;
5151 fail:
5152 return NULL;
5153 }
5154
5155
5156 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5157 PyObject *resultobj = 0;
5158 bool result;
5159
5160 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (bool)wxIsPlatform64Bit();
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 {
5168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5169 }
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxMemorySize result;
5179
5180 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = wxGetFreeMemory();
5184 wxPyEndAllowThreads(__tstate);
5185 if (PyErr_Occurred()) SWIG_fail;
5186 }
5187 {
5188 #if wxUSE_LONGLONG
5189 resultobj = PyLong_FromLongLong((&result)->GetValue());
5190 #else
5191 resultobj = PyInt_FromLong(result);
5192 #endif
5193 }
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj = 0;
5202 wxShutdownFlags arg1 ;
5203 bool result;
5204 int val1 ;
5205 int ecode1 = 0 ;
5206 PyObject * obj0 = 0 ;
5207 char * kwnames[] = {
5208 (char *) "wFlags", NULL
5209 };
5210
5211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5212 ecode1 = SWIG_AsVal_int(obj0, &val1);
5213 if (!SWIG_IsOK(ecode1)) {
5214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5215 }
5216 arg1 = static_cast< wxShutdownFlags >(val1);
5217 {
5218 if (!wxPyCheckForApp()) SWIG_fail;
5219 PyThreadState* __tstate = wxPyBeginAllowThreads();
5220 result = (bool)wxShutdown(arg1);
5221 wxPyEndAllowThreads(__tstate);
5222 if (PyErr_Occurred()) SWIG_fail;
5223 }
5224 {
5225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5226 }
5227 return resultobj;
5228 fail:
5229 return NULL;
5230 }
5231
5232
5233 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5234 PyObject *resultobj = 0;
5235 int arg1 ;
5236 int val1 ;
5237 int ecode1 = 0 ;
5238 PyObject * obj0 = 0 ;
5239 char * kwnames[] = {
5240 (char *) "secs", NULL
5241 };
5242
5243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5244 ecode1 = SWIG_AsVal_int(obj0, &val1);
5245 if (!SWIG_IsOK(ecode1)) {
5246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5247 }
5248 arg1 = static_cast< int >(val1);
5249 {
5250 PyThreadState* __tstate = wxPyBeginAllowThreads();
5251 wxSleep(arg1);
5252 wxPyEndAllowThreads(__tstate);
5253 if (PyErr_Occurred()) SWIG_fail;
5254 }
5255 resultobj = SWIG_Py_Void();
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj = 0;
5264 unsigned long arg1 ;
5265 unsigned long val1 ;
5266 int ecode1 = 0 ;
5267 PyObject * obj0 = 0 ;
5268 char * kwnames[] = {
5269 (char *) "milliseconds", NULL
5270 };
5271
5272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5273 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5274 if (!SWIG_IsOK(ecode1)) {
5275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5276 }
5277 arg1 = static_cast< unsigned long >(val1);
5278 {
5279 PyThreadState* __tstate = wxPyBeginAllowThreads();
5280 wxMilliSleep(arg1);
5281 wxPyEndAllowThreads(__tstate);
5282 if (PyErr_Occurred()) SWIG_fail;
5283 }
5284 resultobj = SWIG_Py_Void();
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 unsigned long arg1 ;
5294 unsigned long val1 ;
5295 int ecode1 = 0 ;
5296 PyObject * obj0 = 0 ;
5297 char * kwnames[] = {
5298 (char *) "microseconds", NULL
5299 };
5300
5301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5302 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5303 if (!SWIG_IsOK(ecode1)) {
5304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5305 }
5306 arg1 = static_cast< unsigned long >(val1);
5307 {
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 wxMicroSleep(arg1);
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 resultobj = SWIG_Py_Void();
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5321 PyObject *resultobj = 0;
5322 bool arg1 ;
5323 bool val1 ;
5324 int ecode1 = 0 ;
5325 PyObject * obj0 = 0 ;
5326 char * kwnames[] = {
5327 (char *) "enable", NULL
5328 };
5329
5330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5331 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5332 if (!SWIG_IsOK(ecode1)) {
5333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5334 }
5335 arg1 = static_cast< bool >(val1);
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 wxEnableTopLevelWindows(arg1);
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 resultobj = SWIG_Py_Void();
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5350 PyObject *resultobj = 0;
5351 wxString *arg1 = 0 ;
5352 wxString result;
5353 bool temp1 = false ;
5354 PyObject * obj0 = 0 ;
5355 char * kwnames[] = {
5356 (char *) "in", NULL
5357 };
5358
5359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5360 {
5361 arg1 = wxString_in_helper(obj0);
5362 if (arg1 == NULL) SWIG_fail;
5363 temp1 = true;
5364 }
5365 {
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 result = wxStripMenuCodes((wxString const &)*arg1);
5368 wxPyEndAllowThreads(__tstate);
5369 if (PyErr_Occurred()) SWIG_fail;
5370 }
5371 {
5372 #if wxUSE_UNICODE
5373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5374 #else
5375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5376 #endif
5377 }
5378 {
5379 if (temp1)
5380 delete arg1;
5381 }
5382 return resultobj;
5383 fail:
5384 {
5385 if (temp1)
5386 delete arg1;
5387 }
5388 return NULL;
5389 }
5390
5391
5392 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5393 PyObject *resultobj = 0;
5394 wxString result;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5397 {
5398 PyThreadState* __tstate = wxPyBeginAllowThreads();
5399 result = wxGetEmailAddress();
5400 wxPyEndAllowThreads(__tstate);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 {
5404 #if wxUSE_UNICODE
5405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5406 #else
5407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5408 #endif
5409 }
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxString result;
5419
5420 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5421 {
5422 PyThreadState* __tstate = wxPyBeginAllowThreads();
5423 result = wxGetHostName();
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 #if wxUSE_UNICODE
5429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5430 #else
5431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5432 #endif
5433 }
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5441 PyObject *resultobj = 0;
5442 wxString result;
5443
5444 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5445 {
5446 PyThreadState* __tstate = wxPyBeginAllowThreads();
5447 result = wxGetFullHostName();
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 {
5452 #if wxUSE_UNICODE
5453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5454 #else
5455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5456 #endif
5457 }
5458 return resultobj;
5459 fail:
5460 return NULL;
5461 }
5462
5463
5464 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5465 PyObject *resultobj = 0;
5466 wxString result;
5467
5468 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = wxGetUserId();
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 {
5476 #if wxUSE_UNICODE
5477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5478 #else
5479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5480 #endif
5481 }
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5489 PyObject *resultobj = 0;
5490 wxString result;
5491
5492 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = wxGetUserName();
5496 wxPyEndAllowThreads(__tstate);
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 {
5500 #if wxUSE_UNICODE
5501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5502 #else
5503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5504 #endif
5505 }
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5513 PyObject *resultobj = 0;
5514 wxString result;
5515
5516 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5517 {
5518 PyThreadState* __tstate = wxPyBeginAllowThreads();
5519 result = wxGetHomeDir();
5520 wxPyEndAllowThreads(__tstate);
5521 if (PyErr_Occurred()) SWIG_fail;
5522 }
5523 {
5524 #if wxUSE_UNICODE
5525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5526 #else
5527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5528 #endif
5529 }
5530 return resultobj;
5531 fail:
5532 return NULL;
5533 }
5534
5535
5536 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5537 PyObject *resultobj = 0;
5538 wxString const &arg1_defvalue = wxPyEmptyString ;
5539 wxString *arg1 = (wxString *) &arg1_defvalue ;
5540 wxString result;
5541 bool temp1 = false ;
5542 PyObject * obj0 = 0 ;
5543 char * kwnames[] = {
5544 (char *) "user", NULL
5545 };
5546
5547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5548 if (obj0) {
5549 {
5550 arg1 = wxString_in_helper(obj0);
5551 if (arg1 == NULL) SWIG_fail;
5552 temp1 = true;
5553 }
5554 }
5555 {
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 result = wxGetUserHome((wxString const &)*arg1);
5558 wxPyEndAllowThreads(__tstate);
5559 if (PyErr_Occurred()) SWIG_fail;
5560 }
5561 {
5562 #if wxUSE_UNICODE
5563 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5564 #else
5565 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5566 #endif
5567 }
5568 {
5569 if (temp1)
5570 delete arg1;
5571 }
5572 return resultobj;
5573 fail:
5574 {
5575 if (temp1)
5576 delete arg1;
5577 }
5578 return NULL;
5579 }
5580
5581
5582 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5583 PyObject *resultobj = 0;
5584 unsigned long result;
5585
5586 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5587 {
5588 PyThreadState* __tstate = wxPyBeginAllowThreads();
5589 result = (unsigned long)wxGetProcessId();
5590 wxPyEndAllowThreads(__tstate);
5591 if (PyErr_Occurred()) SWIG_fail;
5592 }
5593 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5594 return resultobj;
5595 fail:
5596 return NULL;
5597 }
5598
5599
5600 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5601 PyObject *resultobj = 0;
5602
5603 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5604 {
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 wxTrap();
5607 wxPyEndAllowThreads(__tstate);
5608 if (PyErr_Occurred()) SWIG_fail;
5609 }
5610 resultobj = SWIG_Py_Void();
5611 return resultobj;
5612 fail:
5613 return NULL;
5614 }
5615
5616
5617 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5618 PyObject *resultobj = 0;
5619 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5620 wxString *arg1 = (wxString *) &arg1_defvalue ;
5621 wxString const &arg2_defvalue = wxPyEmptyString ;
5622 wxString *arg2 = (wxString *) &arg2_defvalue ;
5623 wxString const &arg3_defvalue = wxPyEmptyString ;
5624 wxString *arg3 = (wxString *) &arg3_defvalue ;
5625 wxString const &arg4_defvalue = wxPyEmptyString ;
5626 wxString *arg4 = (wxString *) &arg4_defvalue ;
5627 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5628 wxString *arg5 = (wxString *) &arg5_defvalue ;
5629 int arg6 = (int) 0 ;
5630 wxWindow *arg7 = (wxWindow *) NULL ;
5631 int arg8 = (int) -1 ;
5632 int arg9 = (int) -1 ;
5633 wxString result;
5634 bool temp1 = false ;
5635 bool temp2 = false ;
5636 bool temp3 = false ;
5637 bool temp4 = false ;
5638 bool temp5 = false ;
5639 int val6 ;
5640 int ecode6 = 0 ;
5641 void *argp7 = 0 ;
5642 int res7 = 0 ;
5643 int val8 ;
5644 int ecode8 = 0 ;
5645 int val9 ;
5646 int ecode9 = 0 ;
5647 PyObject * obj0 = 0 ;
5648 PyObject * obj1 = 0 ;
5649 PyObject * obj2 = 0 ;
5650 PyObject * obj3 = 0 ;
5651 PyObject * obj4 = 0 ;
5652 PyObject * obj5 = 0 ;
5653 PyObject * obj6 = 0 ;
5654 PyObject * obj7 = 0 ;
5655 PyObject * obj8 = 0 ;
5656 char * kwnames[] = {
5657 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5658 };
5659
5660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5661 if (obj0) {
5662 {
5663 arg1 = wxString_in_helper(obj0);
5664 if (arg1 == NULL) SWIG_fail;
5665 temp1 = true;
5666 }
5667 }
5668 if (obj1) {
5669 {
5670 arg2 = wxString_in_helper(obj1);
5671 if (arg2 == NULL) SWIG_fail;
5672 temp2 = true;
5673 }
5674 }
5675 if (obj2) {
5676 {
5677 arg3 = wxString_in_helper(obj2);
5678 if (arg3 == NULL) SWIG_fail;
5679 temp3 = true;
5680 }
5681 }
5682 if (obj3) {
5683 {
5684 arg4 = wxString_in_helper(obj3);
5685 if (arg4 == NULL) SWIG_fail;
5686 temp4 = true;
5687 }
5688 }
5689 if (obj4) {
5690 {
5691 arg5 = wxString_in_helper(obj4);
5692 if (arg5 == NULL) SWIG_fail;
5693 temp5 = true;
5694 }
5695 }
5696 if (obj5) {
5697 ecode6 = SWIG_AsVal_int(obj5, &val6);
5698 if (!SWIG_IsOK(ecode6)) {
5699 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5700 }
5701 arg6 = static_cast< int >(val6);
5702 }
5703 if (obj6) {
5704 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5705 if (!SWIG_IsOK(res7)) {
5706 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5707 }
5708 arg7 = reinterpret_cast< wxWindow * >(argp7);
5709 }
5710 if (obj7) {
5711 ecode8 = SWIG_AsVal_int(obj7, &val8);
5712 if (!SWIG_IsOK(ecode8)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5714 }
5715 arg8 = static_cast< int >(val8);
5716 }
5717 if (obj8) {
5718 ecode9 = SWIG_AsVal_int(obj8, &val9);
5719 if (!SWIG_IsOK(ecode9)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5721 }
5722 arg9 = static_cast< int >(val9);
5723 }
5724 {
5725 if (!wxPyCheckForApp()) SWIG_fail;
5726 PyThreadState* __tstate = wxPyBeginAllowThreads();
5727 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5728 wxPyEndAllowThreads(__tstate);
5729 if (PyErr_Occurred()) SWIG_fail;
5730 }
5731 {
5732 #if wxUSE_UNICODE
5733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5734 #else
5735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5736 #endif
5737 }
5738 {
5739 if (temp1)
5740 delete arg1;
5741 }
5742 {
5743 if (temp2)
5744 delete arg2;
5745 }
5746 {
5747 if (temp3)
5748 delete arg3;
5749 }
5750 {
5751 if (temp4)
5752 delete arg4;
5753 }
5754 {
5755 if (temp5)
5756 delete arg5;
5757 }
5758 return resultobj;
5759 fail:
5760 {
5761 if (temp1)
5762 delete arg1;
5763 }
5764 {
5765 if (temp2)
5766 delete arg2;
5767 }
5768 {
5769 if (temp3)
5770 delete arg3;
5771 }
5772 {
5773 if (temp4)
5774 delete arg4;
5775 }
5776 {
5777 if (temp5)
5778 delete arg5;
5779 }
5780 return NULL;
5781 }
5782
5783
5784 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj = 0;
5786 wxString *arg1 = 0 ;
5787 wxString *arg2 = 0 ;
5788 wxString const &arg3_defvalue = wxPyEmptyString ;
5789 wxString *arg3 = (wxString *) &arg3_defvalue ;
5790 wxWindow *arg4 = (wxWindow *) NULL ;
5791 wxString result;
5792 bool temp1 = false ;
5793 bool temp2 = false ;
5794 bool temp3 = false ;
5795 void *argp4 = 0 ;
5796 int res4 = 0 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 PyObject * obj2 = 0 ;
5800 PyObject * obj3 = 0 ;
5801 char * kwnames[] = {
5802 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5803 };
5804
5805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5806 {
5807 arg1 = wxString_in_helper(obj0);
5808 if (arg1 == NULL) SWIG_fail;
5809 temp1 = true;
5810 }
5811 {
5812 arg2 = wxString_in_helper(obj1);
5813 if (arg2 == NULL) SWIG_fail;
5814 temp2 = true;
5815 }
5816 if (obj2) {
5817 {
5818 arg3 = wxString_in_helper(obj2);
5819 if (arg3 == NULL) SWIG_fail;
5820 temp3 = true;
5821 }
5822 }
5823 if (obj3) {
5824 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5825 if (!SWIG_IsOK(res4)) {
5826 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5827 }
5828 arg4 = reinterpret_cast< wxWindow * >(argp4);
5829 }
5830 {
5831 if (!wxPyCheckForApp()) SWIG_fail;
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 #if wxUSE_UNICODE
5839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5840 #else
5841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5842 #endif
5843 }
5844 {
5845 if (temp1)
5846 delete arg1;
5847 }
5848 {
5849 if (temp2)
5850 delete arg2;
5851 }
5852 {
5853 if (temp3)
5854 delete arg3;
5855 }
5856 return resultobj;
5857 fail:
5858 {
5859 if (temp1)
5860 delete arg1;
5861 }
5862 {
5863 if (temp2)
5864 delete arg2;
5865 }
5866 {
5867 if (temp3)
5868 delete arg3;
5869 }
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj = 0;
5876 wxString *arg1 = 0 ;
5877 wxString *arg2 = 0 ;
5878 wxString const &arg3_defvalue = wxPyEmptyString ;
5879 wxString *arg3 = (wxString *) &arg3_defvalue ;
5880 wxWindow *arg4 = (wxWindow *) NULL ;
5881 wxString result;
5882 bool temp1 = false ;
5883 bool temp2 = false ;
5884 bool temp3 = false ;
5885 void *argp4 = 0 ;
5886 int res4 = 0 ;
5887 PyObject * obj0 = 0 ;
5888 PyObject * obj1 = 0 ;
5889 PyObject * obj2 = 0 ;
5890 PyObject * obj3 = 0 ;
5891 char * kwnames[] = {
5892 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5893 };
5894
5895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5896 {
5897 arg1 = wxString_in_helper(obj0);
5898 if (arg1 == NULL) SWIG_fail;
5899 temp1 = true;
5900 }
5901 {
5902 arg2 = wxString_in_helper(obj1);
5903 if (arg2 == NULL) SWIG_fail;
5904 temp2 = true;
5905 }
5906 if (obj2) {
5907 {
5908 arg3 = wxString_in_helper(obj2);
5909 if (arg3 == NULL) SWIG_fail;
5910 temp3 = true;
5911 }
5912 }
5913 if (obj3) {
5914 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5915 if (!SWIG_IsOK(res4)) {
5916 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5917 }
5918 arg4 = reinterpret_cast< wxWindow * >(argp4);
5919 }
5920 {
5921 if (!wxPyCheckForApp()) SWIG_fail;
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5924 wxPyEndAllowThreads(__tstate);
5925 if (PyErr_Occurred()) SWIG_fail;
5926 }
5927 {
5928 #if wxUSE_UNICODE
5929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5930 #else
5931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5932 #endif
5933 }
5934 {
5935 if (temp1)
5936 delete arg1;
5937 }
5938 {
5939 if (temp2)
5940 delete arg2;
5941 }
5942 {
5943 if (temp3)
5944 delete arg3;
5945 }
5946 return resultobj;
5947 fail:
5948 {
5949 if (temp1)
5950 delete arg1;
5951 }
5952 {
5953 if (temp2)
5954 delete arg2;
5955 }
5956 {
5957 if (temp3)
5958 delete arg3;
5959 }
5960 return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = 0;
5966 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5967 wxString *arg1 = (wxString *) &arg1_defvalue ;
5968 wxString const &arg2_defvalue = wxPyEmptyString ;
5969 wxString *arg2 = (wxString *) &arg2_defvalue ;
5970 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5971 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5972 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5973 wxWindow *arg5 = (wxWindow *) NULL ;
5974 wxString result;
5975 bool temp1 = false ;
5976 bool temp2 = false ;
5977 long val3 ;
5978 int ecode3 = 0 ;
5979 wxPoint temp4 ;
5980 void *argp5 = 0 ;
5981 int res5 = 0 ;
5982 PyObject * obj0 = 0 ;
5983 PyObject * obj1 = 0 ;
5984 PyObject * obj2 = 0 ;
5985 PyObject * obj3 = 0 ;
5986 PyObject * obj4 = 0 ;
5987 char * kwnames[] = {
5988 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5989 };
5990
5991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5992 if (obj0) {
5993 {
5994 arg1 = wxString_in_helper(obj0);
5995 if (arg1 == NULL) SWIG_fail;
5996 temp1 = true;
5997 }
5998 }
5999 if (obj1) {
6000 {
6001 arg2 = wxString_in_helper(obj1);
6002 if (arg2 == NULL) SWIG_fail;
6003 temp2 = true;
6004 }
6005 }
6006 if (obj2) {
6007 ecode3 = SWIG_AsVal_long(obj2, &val3);
6008 if (!SWIG_IsOK(ecode3)) {
6009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6010 }
6011 arg3 = static_cast< long >(val3);
6012 }
6013 if (obj3) {
6014 {
6015 arg4 = &temp4;
6016 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6017 }
6018 }
6019 if (obj4) {
6020 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6021 if (!SWIG_IsOK(res5)) {
6022 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6023 }
6024 arg5 = reinterpret_cast< wxWindow * >(argp5);
6025 }
6026 {
6027 if (!wxPyCheckForApp()) SWIG_fail;
6028 PyThreadState* __tstate = wxPyBeginAllowThreads();
6029 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 #if wxUSE_UNICODE
6035 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6036 #else
6037 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6038 #endif
6039 }
6040 {
6041 if (temp1)
6042 delete arg1;
6043 }
6044 {
6045 if (temp2)
6046 delete arg2;
6047 }
6048 return resultobj;
6049 fail:
6050 {
6051 if (temp1)
6052 delete arg1;
6053 }
6054 {
6055 if (temp2)
6056 delete arg2;
6057 }
6058 return NULL;
6059 }
6060
6061
6062 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6063 PyObject *resultobj = 0;
6064 wxString *arg1 = 0 ;
6065 wxString const &arg2_defvalue = wxPyEmptyString ;
6066 wxString *arg2 = (wxString *) &arg2_defvalue ;
6067 wxString const &arg3_defvalue = wxPyEmptyString ;
6068 wxString *arg3 = (wxString *) &arg3_defvalue ;
6069 wxWindow *arg4 = (wxWindow *) NULL ;
6070 int arg5 = (int) -1 ;
6071 int arg6 = (int) -1 ;
6072 bool arg7 = (bool) true ;
6073 wxString result;
6074 bool temp1 = false ;
6075 bool temp2 = false ;
6076 bool temp3 = false ;
6077 void *argp4 = 0 ;
6078 int res4 = 0 ;
6079 int val5 ;
6080 int ecode5 = 0 ;
6081 int val6 ;
6082 int ecode6 = 0 ;
6083 bool val7 ;
6084 int ecode7 = 0 ;
6085 PyObject * obj0 = 0 ;
6086 PyObject * obj1 = 0 ;
6087 PyObject * obj2 = 0 ;
6088 PyObject * obj3 = 0 ;
6089 PyObject * obj4 = 0 ;
6090 PyObject * obj5 = 0 ;
6091 PyObject * obj6 = 0 ;
6092 char * kwnames[] = {
6093 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6094 };
6095
6096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6097 {
6098 arg1 = wxString_in_helper(obj0);
6099 if (arg1 == NULL) SWIG_fail;
6100 temp1 = true;
6101 }
6102 if (obj1) {
6103 {
6104 arg2 = wxString_in_helper(obj1);
6105 if (arg2 == NULL) SWIG_fail;
6106 temp2 = true;
6107 }
6108 }
6109 if (obj2) {
6110 {
6111 arg3 = wxString_in_helper(obj2);
6112 if (arg3 == NULL) SWIG_fail;
6113 temp3 = true;
6114 }
6115 }
6116 if (obj3) {
6117 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6118 if (!SWIG_IsOK(res4)) {
6119 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6120 }
6121 arg4 = reinterpret_cast< wxWindow * >(argp4);
6122 }
6123 if (obj4) {
6124 ecode5 = SWIG_AsVal_int(obj4, &val5);
6125 if (!SWIG_IsOK(ecode5)) {
6126 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6127 }
6128 arg5 = static_cast< int >(val5);
6129 }
6130 if (obj5) {
6131 ecode6 = SWIG_AsVal_int(obj5, &val6);
6132 if (!SWIG_IsOK(ecode6)) {
6133 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6134 }
6135 arg6 = static_cast< int >(val6);
6136 }
6137 if (obj6) {
6138 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6139 if (!SWIG_IsOK(ecode7)) {
6140 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6141 }
6142 arg7 = static_cast< bool >(val7);
6143 }
6144 {
6145 if (!wxPyCheckForApp()) SWIG_fail;
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 {
6152 #if wxUSE_UNICODE
6153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6154 #else
6155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6156 #endif
6157 }
6158 {
6159 if (temp1)
6160 delete arg1;
6161 }
6162 {
6163 if (temp2)
6164 delete arg2;
6165 }
6166 {
6167 if (temp3)
6168 delete arg3;
6169 }
6170 return resultobj;
6171 fail:
6172 {
6173 if (temp1)
6174 delete arg1;
6175 }
6176 {
6177 if (temp2)
6178 delete arg2;
6179 }
6180 {
6181 if (temp3)
6182 delete arg3;
6183 }
6184 return NULL;
6185 }
6186
6187
6188 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6189 PyObject *resultobj = 0;
6190 wxString *arg1 = 0 ;
6191 wxString const &arg2_defvalue = wxPyEmptyString ;
6192 wxString *arg2 = (wxString *) &arg2_defvalue ;
6193 wxString const &arg3_defvalue = wxPyEmptyString ;
6194 wxString *arg3 = (wxString *) &arg3_defvalue ;
6195 wxWindow *arg4 = (wxWindow *) NULL ;
6196 wxString result;
6197 bool temp1 = false ;
6198 bool temp2 = false ;
6199 bool temp3 = false ;
6200 void *argp4 = 0 ;
6201 int res4 = 0 ;
6202 PyObject * obj0 = 0 ;
6203 PyObject * obj1 = 0 ;
6204 PyObject * obj2 = 0 ;
6205 PyObject * obj3 = 0 ;
6206 char * kwnames[] = {
6207 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6208 };
6209
6210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6211 {
6212 arg1 = wxString_in_helper(obj0);
6213 if (arg1 == NULL) SWIG_fail;
6214 temp1 = true;
6215 }
6216 if (obj1) {
6217 {
6218 arg2 = wxString_in_helper(obj1);
6219 if (arg2 == NULL) SWIG_fail;
6220 temp2 = true;
6221 }
6222 }
6223 if (obj2) {
6224 {
6225 arg3 = wxString_in_helper(obj2);
6226 if (arg3 == NULL) SWIG_fail;
6227 temp3 = true;
6228 }
6229 }
6230 if (obj3) {
6231 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6232 if (!SWIG_IsOK(res4)) {
6233 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6234 }
6235 arg4 = reinterpret_cast< wxWindow * >(argp4);
6236 }
6237 {
6238 if (!wxPyCheckForApp()) SWIG_fail;
6239 PyThreadState* __tstate = wxPyBeginAllowThreads();
6240 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6241 wxPyEndAllowThreads(__tstate);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 {
6245 #if wxUSE_UNICODE
6246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6247 #else
6248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6249 #endif
6250 }
6251 {
6252 if (temp1)
6253 delete arg1;
6254 }
6255 {
6256 if (temp2)
6257 delete arg2;
6258 }
6259 {
6260 if (temp3)
6261 delete arg3;
6262 }
6263 return resultobj;
6264 fail:
6265 {
6266 if (temp1)
6267 delete arg1;
6268 }
6269 {
6270 if (temp2)
6271 delete arg2;
6272 }
6273 {
6274 if (temp3)
6275 delete arg3;
6276 }
6277 return NULL;
6278 }
6279
6280
6281 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj = 0;
6283 wxString *arg1 = 0 ;
6284 wxString *arg2 = 0 ;
6285 int arg3 ;
6286 wxString *arg4 = (wxString *) 0 ;
6287 wxWindow *arg5 = (wxWindow *) NULL ;
6288 int arg6 = (int) -1 ;
6289 int arg7 = (int) -1 ;
6290 bool arg8 = (bool) true ;
6291 int arg9 = (int) 150 ;
6292 int arg10 = (int) 200 ;
6293 wxString result;
6294 bool temp1 = false ;
6295 bool temp2 = false ;
6296 void *argp5 = 0 ;
6297 int res5 = 0 ;
6298 int val6 ;
6299 int ecode6 = 0 ;
6300 int val7 ;
6301 int ecode7 = 0 ;
6302 bool val8 ;
6303 int ecode8 = 0 ;
6304 int val9 ;
6305 int ecode9 = 0 ;
6306 int val10 ;
6307 int ecode10 = 0 ;
6308 PyObject * obj0 = 0 ;
6309 PyObject * obj1 = 0 ;
6310 PyObject * obj2 = 0 ;
6311 PyObject * obj3 = 0 ;
6312 PyObject * obj4 = 0 ;
6313 PyObject * obj5 = 0 ;
6314 PyObject * obj6 = 0 ;
6315 PyObject * obj7 = 0 ;
6316 PyObject * obj8 = 0 ;
6317 char * kwnames[] = {
6318 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6319 };
6320
6321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6322 {
6323 arg1 = wxString_in_helper(obj0);
6324 if (arg1 == NULL) SWIG_fail;
6325 temp1 = true;
6326 }
6327 {
6328 arg2 = wxString_in_helper(obj1);
6329 if (arg2 == NULL) SWIG_fail;
6330 temp2 = true;
6331 }
6332 {
6333 arg3 = PyList_Size(obj2);
6334 arg4 = wxString_LIST_helper(obj2);
6335 if (arg4 == NULL) SWIG_fail;
6336 }
6337 if (obj3) {
6338 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6339 if (!SWIG_IsOK(res5)) {
6340 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6341 }
6342 arg5 = reinterpret_cast< wxWindow * >(argp5);
6343 }
6344 if (obj4) {
6345 ecode6 = SWIG_AsVal_int(obj4, &val6);
6346 if (!SWIG_IsOK(ecode6)) {
6347 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6348 }
6349 arg6 = static_cast< int >(val6);
6350 }
6351 if (obj5) {
6352 ecode7 = SWIG_AsVal_int(obj5, &val7);
6353 if (!SWIG_IsOK(ecode7)) {
6354 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6355 }
6356 arg7 = static_cast< int >(val7);
6357 }
6358 if (obj6) {
6359 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6360 if (!SWIG_IsOK(ecode8)) {
6361 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6362 }
6363 arg8 = static_cast< bool >(val8);
6364 }
6365 if (obj7) {
6366 ecode9 = SWIG_AsVal_int(obj7, &val9);
6367 if (!SWIG_IsOK(ecode9)) {
6368 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6369 }
6370 arg9 = static_cast< int >(val9);
6371 }
6372 if (obj8) {
6373 ecode10 = SWIG_AsVal_int(obj8, &val10);
6374 if (!SWIG_IsOK(ecode10)) {
6375 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6376 }
6377 arg10 = static_cast< int >(val10);
6378 }
6379 {
6380 if (!wxPyCheckForApp()) SWIG_fail;
6381 PyThreadState* __tstate = wxPyBeginAllowThreads();
6382 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6383 wxPyEndAllowThreads(__tstate);
6384 if (PyErr_Occurred()) SWIG_fail;
6385 }
6386 {
6387 #if wxUSE_UNICODE
6388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6389 #else
6390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6391 #endif
6392 }
6393 {
6394 if (temp1)
6395 delete arg1;
6396 }
6397 {
6398 if (temp2)
6399 delete arg2;
6400 }
6401 {
6402 if (arg4) delete [] arg4;
6403 }
6404 return resultobj;
6405 fail:
6406 {
6407 if (temp1)
6408 delete arg1;
6409 }
6410 {
6411 if (temp2)
6412 delete arg2;
6413 }
6414 {
6415 if (arg4) delete [] arg4;
6416 }
6417 return NULL;
6418 }
6419
6420
6421 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj = 0;
6423 wxString *arg1 = 0 ;
6424 wxString *arg2 = 0 ;
6425 int arg3 ;
6426 wxString *arg4 = (wxString *) 0 ;
6427 wxWindow *arg5 = (wxWindow *) NULL ;
6428 int arg6 = (int) -1 ;
6429 int arg7 = (int) -1 ;
6430 bool arg8 = (bool) true ;
6431 int arg9 = (int) 150 ;
6432 int arg10 = (int) 200 ;
6433 int result;
6434 bool temp1 = false ;
6435 bool temp2 = false ;
6436 void *argp5 = 0 ;
6437 int res5 = 0 ;
6438 int val6 ;
6439 int ecode6 = 0 ;
6440 int val7 ;
6441 int ecode7 = 0 ;
6442 bool val8 ;
6443 int ecode8 = 0 ;
6444 int val9 ;
6445 int ecode9 = 0 ;
6446 int val10 ;
6447 int ecode10 = 0 ;
6448 PyObject * obj0 = 0 ;
6449 PyObject * obj1 = 0 ;
6450 PyObject * obj2 = 0 ;
6451 PyObject * obj3 = 0 ;
6452 PyObject * obj4 = 0 ;
6453 PyObject * obj5 = 0 ;
6454 PyObject * obj6 = 0 ;
6455 PyObject * obj7 = 0 ;
6456 PyObject * obj8 = 0 ;
6457 char * kwnames[] = {
6458 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6459 };
6460
6461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6462 {
6463 arg1 = wxString_in_helper(obj0);
6464 if (arg1 == NULL) SWIG_fail;
6465 temp1 = true;
6466 }
6467 {
6468 arg2 = wxString_in_helper(obj1);
6469 if (arg2 == NULL) SWIG_fail;
6470 temp2 = true;
6471 }
6472 {
6473 arg3 = PyList_Size(obj2);
6474 arg4 = wxString_LIST_helper(obj2);
6475 if (arg4 == NULL) SWIG_fail;
6476 }
6477 if (obj3) {
6478 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6479 if (!SWIG_IsOK(res5)) {
6480 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6481 }
6482 arg5 = reinterpret_cast< wxWindow * >(argp5);
6483 }
6484 if (obj4) {
6485 ecode6 = SWIG_AsVal_int(obj4, &val6);
6486 if (!SWIG_IsOK(ecode6)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6488 }
6489 arg6 = static_cast< int >(val6);
6490 }
6491 if (obj5) {
6492 ecode7 = SWIG_AsVal_int(obj5, &val7);
6493 if (!SWIG_IsOK(ecode7)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6495 }
6496 arg7 = static_cast< int >(val7);
6497 }
6498 if (obj6) {
6499 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6500 if (!SWIG_IsOK(ecode8)) {
6501 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6502 }
6503 arg8 = static_cast< bool >(val8);
6504 }
6505 if (obj7) {
6506 ecode9 = SWIG_AsVal_int(obj7, &val9);
6507 if (!SWIG_IsOK(ecode9)) {
6508 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6509 }
6510 arg9 = static_cast< int >(val9);
6511 }
6512 if (obj8) {
6513 ecode10 = SWIG_AsVal_int(obj8, &val10);
6514 if (!SWIG_IsOK(ecode10)) {
6515 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6516 }
6517 arg10 = static_cast< int >(val10);
6518 }
6519 {
6520 if (!wxPyCheckForApp()) SWIG_fail;
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_From_int(static_cast< int >(result));
6527 {
6528 if (temp1)
6529 delete arg1;
6530 }
6531 {
6532 if (temp2)
6533 delete arg2;
6534 }
6535 {
6536 if (arg4) delete [] arg4;
6537 }
6538 return resultobj;
6539 fail:
6540 {
6541 if (temp1)
6542 delete arg1;
6543 }
6544 {
6545 if (temp2)
6546 delete arg2;
6547 }
6548 {
6549 if (arg4) delete [] arg4;
6550 }
6551 return NULL;
6552 }
6553
6554
6555 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6556 PyObject *resultobj = 0;
6557 wxString *arg1 = 0 ;
6558 wxString const &arg2_defvalue = wxPyEmptyString ;
6559 wxString *arg2 = (wxString *) &arg2_defvalue ;
6560 int arg3 = (int) wxOK|wxCENTRE ;
6561 wxWindow *arg4 = (wxWindow *) NULL ;
6562 int arg5 = (int) -1 ;
6563 int arg6 = (int) -1 ;
6564 int result;
6565 bool temp1 = false ;
6566 bool temp2 = false ;
6567 int val3 ;
6568 int ecode3 = 0 ;
6569 void *argp4 = 0 ;
6570 int res4 = 0 ;
6571 int val5 ;
6572 int ecode5 = 0 ;
6573 int val6 ;
6574 int ecode6 = 0 ;
6575 PyObject * obj0 = 0 ;
6576 PyObject * obj1 = 0 ;
6577 PyObject * obj2 = 0 ;
6578 PyObject * obj3 = 0 ;
6579 PyObject * obj4 = 0 ;
6580 PyObject * obj5 = 0 ;
6581 char * kwnames[] = {
6582 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6583 };
6584
6585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6586 {
6587 arg1 = wxString_in_helper(obj0);
6588 if (arg1 == NULL) SWIG_fail;
6589 temp1 = true;
6590 }
6591 if (obj1) {
6592 {
6593 arg2 = wxString_in_helper(obj1);
6594 if (arg2 == NULL) SWIG_fail;
6595 temp2 = true;
6596 }
6597 }
6598 if (obj2) {
6599 ecode3 = SWIG_AsVal_int(obj2, &val3);
6600 if (!SWIG_IsOK(ecode3)) {
6601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6602 }
6603 arg3 = static_cast< int >(val3);
6604 }
6605 if (obj3) {
6606 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6607 if (!SWIG_IsOK(res4)) {
6608 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6609 }
6610 arg4 = reinterpret_cast< wxWindow * >(argp4);
6611 }
6612 if (obj4) {
6613 ecode5 = SWIG_AsVal_int(obj4, &val5);
6614 if (!SWIG_IsOK(ecode5)) {
6615 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6616 }
6617 arg5 = static_cast< int >(val5);
6618 }
6619 if (obj5) {
6620 ecode6 = SWIG_AsVal_int(obj5, &val6);
6621 if (!SWIG_IsOK(ecode6)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6623 }
6624 arg6 = static_cast< int >(val6);
6625 }
6626 {
6627 if (!wxPyCheckForApp()) SWIG_fail;
6628 PyThreadState* __tstate = wxPyBeginAllowThreads();
6629 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6630 wxPyEndAllowThreads(__tstate);
6631 if (PyErr_Occurred()) SWIG_fail;
6632 }
6633 resultobj = SWIG_From_int(static_cast< int >(result));
6634 {
6635 if (temp1)
6636 delete arg1;
6637 }
6638 {
6639 if (temp2)
6640 delete arg2;
6641 }
6642 return resultobj;
6643 fail:
6644 {
6645 if (temp1)
6646 delete arg1;
6647 }
6648 {
6649 if (temp2)
6650 delete arg2;
6651 }
6652 return NULL;
6653 }
6654
6655
6656 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj = 0;
6658 wxString *arg1 = 0 ;
6659 wxString *arg2 = 0 ;
6660 wxString *arg3 = 0 ;
6661 long arg4 ;
6662 long arg5 = (long) 0 ;
6663 long arg6 = (long) 100 ;
6664 wxWindow *arg7 = (wxWindow *) NULL ;
6665 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6666 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6667 long result;
6668 bool temp1 = false ;
6669 bool temp2 = false ;
6670 bool temp3 = false ;
6671 long val4 ;
6672 int ecode4 = 0 ;
6673 long val5 ;
6674 int ecode5 = 0 ;
6675 long val6 ;
6676 int ecode6 = 0 ;
6677 void *argp7 = 0 ;
6678 int res7 = 0 ;
6679 wxPoint temp8 ;
6680 PyObject * obj0 = 0 ;
6681 PyObject * obj1 = 0 ;
6682 PyObject * obj2 = 0 ;
6683 PyObject * obj3 = 0 ;
6684 PyObject * obj4 = 0 ;
6685 PyObject * obj5 = 0 ;
6686 PyObject * obj6 = 0 ;
6687 PyObject * obj7 = 0 ;
6688 char * kwnames[] = {
6689 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6690 };
6691
6692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6693 {
6694 arg1 = wxString_in_helper(obj0);
6695 if (arg1 == NULL) SWIG_fail;
6696 temp1 = true;
6697 }
6698 {
6699 arg2 = wxString_in_helper(obj1);
6700 if (arg2 == NULL) SWIG_fail;
6701 temp2 = true;
6702 }
6703 {
6704 arg3 = wxString_in_helper(obj2);
6705 if (arg3 == NULL) SWIG_fail;
6706 temp3 = true;
6707 }
6708 ecode4 = SWIG_AsVal_long(obj3, &val4);
6709 if (!SWIG_IsOK(ecode4)) {
6710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6711 }
6712 arg4 = static_cast< long >(val4);
6713 if (obj4) {
6714 ecode5 = SWIG_AsVal_long(obj4, &val5);
6715 if (!SWIG_IsOK(ecode5)) {
6716 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6717 }
6718 arg5 = static_cast< long >(val5);
6719 }
6720 if (obj5) {
6721 ecode6 = SWIG_AsVal_long(obj5, &val6);
6722 if (!SWIG_IsOK(ecode6)) {
6723 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6724 }
6725 arg6 = static_cast< long >(val6);
6726 }
6727 if (obj6) {
6728 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6729 if (!SWIG_IsOK(res7)) {
6730 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6731 }
6732 arg7 = reinterpret_cast< wxWindow * >(argp7);
6733 }
6734 if (obj7) {
6735 {
6736 arg8 = &temp8;
6737 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6738 }
6739 }
6740 {
6741 if (!wxPyCheckForApp()) SWIG_fail;
6742 PyThreadState* __tstate = wxPyBeginAllowThreads();
6743 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 resultobj = SWIG_From_long(static_cast< long >(result));
6748 {
6749 if (temp1)
6750 delete arg1;
6751 }
6752 {
6753 if (temp2)
6754 delete arg2;
6755 }
6756 {
6757 if (temp3)
6758 delete arg3;
6759 }
6760 return resultobj;
6761 fail:
6762 {
6763 if (temp1)
6764 delete arg1;
6765 }
6766 {
6767 if (temp2)
6768 delete arg2;
6769 }
6770 {
6771 if (temp3)
6772 delete arg3;
6773 }
6774 return NULL;
6775 }
6776
6777
6778 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6779 PyObject *resultobj = 0;
6780 bool result;
6781
6782 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6783 {
6784 if (!wxPyCheckForApp()) SWIG_fail;
6785 PyThreadState* __tstate = wxPyBeginAllowThreads();
6786 result = (bool)wxColourDisplay();
6787 wxPyEndAllowThreads(__tstate);
6788 if (PyErr_Occurred()) SWIG_fail;
6789 }
6790 {
6791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6792 }
6793 return resultobj;
6794 fail:
6795 return NULL;
6796 }
6797
6798
6799 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6800 PyObject *resultobj = 0;
6801 int result;
6802
6803 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6804 {
6805 if (!wxPyCheckForApp()) SWIG_fail;
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 result = (int)wxDisplayDepth();
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 resultobj = SWIG_From_int(static_cast< int >(result));
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6819 PyObject *resultobj = 0;
6820 int result;
6821
6822 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6823 {
6824 if (!wxPyCheckForApp()) SWIG_fail;
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (int)wxGetDisplayDepth();
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_From_int(static_cast< int >(result));
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6838 PyObject *resultobj = 0;
6839 int *arg1 = (int *) 0 ;
6840 int *arg2 = (int *) 0 ;
6841 int temp1 ;
6842 int res1 = SWIG_TMPOBJ ;
6843 int temp2 ;
6844 int res2 = SWIG_TMPOBJ ;
6845
6846 arg1 = &temp1;
6847 arg2 = &temp2;
6848 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6849 {
6850 if (!wxPyCheckForApp()) SWIG_fail;
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 wxDisplaySize(arg1,arg2);
6853 wxPyEndAllowThreads(__tstate);
6854 if (PyErr_Occurred()) SWIG_fail;
6855 }
6856 resultobj = SWIG_Py_Void();
6857 if (SWIG_IsTmpObj(res1)) {
6858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6859 } else {
6860 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6862 }
6863 if (SWIG_IsTmpObj(res2)) {
6864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6865 } else {
6866 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6868 }
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6876 PyObject *resultobj = 0;
6877 wxSize result;
6878
6879 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6880 {
6881 if (!wxPyCheckForApp()) SWIG_fail;
6882 PyThreadState* __tstate = wxPyBeginAllowThreads();
6883 result = wxGetDisplaySize();
6884 wxPyEndAllowThreads(__tstate);
6885 if (PyErr_Occurred()) SWIG_fail;
6886 }
6887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6888 return resultobj;
6889 fail:
6890 return NULL;
6891 }
6892
6893
6894 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6895 PyObject *resultobj = 0;
6896 int *arg1 = (int *) 0 ;
6897 int *arg2 = (int *) 0 ;
6898 int temp1 ;
6899 int res1 = SWIG_TMPOBJ ;
6900 int temp2 ;
6901 int res2 = SWIG_TMPOBJ ;
6902
6903 arg1 = &temp1;
6904 arg2 = &temp2;
6905 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6906 {
6907 if (!wxPyCheckForApp()) SWIG_fail;
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 wxDisplaySizeMM(arg1,arg2);
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_Py_Void();
6914 if (SWIG_IsTmpObj(res1)) {
6915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6916 } else {
6917 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6919 }
6920 if (SWIG_IsTmpObj(res2)) {
6921 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6922 } else {
6923 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6925 }
6926 return resultobj;
6927 fail:
6928 return NULL;
6929 }
6930
6931
6932 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6933 PyObject *resultobj = 0;
6934 wxSize result;
6935
6936 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6937 {
6938 if (!wxPyCheckForApp()) SWIG_fail;
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 result = wxGetDisplaySizeMM();
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6952 PyObject *resultobj = 0;
6953 int *arg1 = (int *) 0 ;
6954 int *arg2 = (int *) 0 ;
6955 int *arg3 = (int *) 0 ;
6956 int *arg4 = (int *) 0 ;
6957 int temp1 ;
6958 int res1 = SWIG_TMPOBJ ;
6959 int temp2 ;
6960 int res2 = SWIG_TMPOBJ ;
6961 int temp3 ;
6962 int res3 = SWIG_TMPOBJ ;
6963 int temp4 ;
6964 int res4 = SWIG_TMPOBJ ;
6965
6966 arg1 = &temp1;
6967 arg2 = &temp2;
6968 arg3 = &temp3;
6969 arg4 = &temp4;
6970 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6971 {
6972 if (!wxPyCheckForApp()) SWIG_fail;
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6975 wxPyEndAllowThreads(__tstate);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_Py_Void();
6979 if (SWIG_IsTmpObj(res1)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6984 }
6985 if (SWIG_IsTmpObj(res2)) {
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6987 } else {
6988 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6990 }
6991 if (SWIG_IsTmpObj(res3)) {
6992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6993 } else {
6994 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6996 }
6997 if (SWIG_IsTmpObj(res4)) {
6998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6999 } else {
7000 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
7002 }
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7010 PyObject *resultobj = 0;
7011 wxRect result;
7012
7013 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7014 {
7015 if (!wxPyCheckForApp()) SWIG_fail;
7016 PyThreadState* __tstate = wxPyBeginAllowThreads();
7017 result = wxGetClientDisplayRect();
7018 wxPyEndAllowThreads(__tstate);
7019 if (PyErr_Occurred()) SWIG_fail;
7020 }
7021 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7022 return resultobj;
7023 fail:
7024 return NULL;
7025 }
7026
7027
7028 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7029 PyObject *resultobj = 0;
7030 wxCursor *arg1 = 0 ;
7031 void *argp1 = 0 ;
7032 int res1 = 0 ;
7033 PyObject * obj0 = 0 ;
7034 char * kwnames[] = {
7035 (char *) "cursor", NULL
7036 };
7037
7038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7039 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7040 if (!SWIG_IsOK(res1)) {
7041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7042 }
7043 if (!argp1) {
7044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7045 }
7046 arg1 = reinterpret_cast< wxCursor * >(argp1);
7047 {
7048 if (!wxPyCheckForApp()) SWIG_fail;
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 wxSetCursor(*arg1);
7051 wxPyEndAllowThreads(__tstate);
7052 if (PyErr_Occurred()) SWIG_fail;
7053 }
7054 resultobj = SWIG_Py_Void();
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062 PyObject *resultobj = 0;
7063 void *result = 0 ;
7064
7065 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7066 {
7067 if (!wxPyCheckForApp()) SWIG_fail;
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (void *)wxGetXDisplay();
7070 wxPyEndAllowThreads(__tstate);
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7074 return resultobj;
7075 fail:
7076 return NULL;
7077 }
7078
7079
7080 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7081 PyObject *resultobj = 0;
7082 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7083 void *argp1 = 0 ;
7084 int res1 = 0 ;
7085 PyObject * obj0 = 0 ;
7086 char * kwnames[] = {
7087 (char *) "cursor", NULL
7088 };
7089
7090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7091 if (obj0) {
7092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7095 }
7096 arg1 = reinterpret_cast< wxCursor * >(argp1);
7097 }
7098 {
7099 if (!wxPyCheckForApp()) SWIG_fail;
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 wxBeginBusyCursor(arg1);
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 resultobj = SWIG_Py_Void();
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7113 PyObject *resultobj = 0;
7114 wxPoint result;
7115
7116 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7117 {
7118 if (!wxPyCheckForApp()) SWIG_fail;
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = wxGetMousePosition();
7121 wxPyEndAllowThreads(__tstate);
7122 if (PyErr_Occurred()) SWIG_fail;
7123 }
7124 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7125 return resultobj;
7126 fail:
7127 return NULL;
7128 }
7129
7130
7131 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7132 PyObject *resultobj = 0;
7133 wxWindow *result = 0 ;
7134
7135 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7136 {
7137 if (!wxPyCheckForApp()) SWIG_fail;
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 result = (wxWindow *)FindWindowAtPointer();
7140 wxPyEndAllowThreads(__tstate);
7141 if (PyErr_Occurred()) SWIG_fail;
7142 }
7143 {
7144 resultobj = wxPyMake_wxObject(result, 0);
7145 }
7146 return resultobj;
7147 fail:
7148 return NULL;
7149 }
7150
7151
7152 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7153 PyObject *resultobj = 0;
7154 wxWindow *result = 0 ;
7155
7156 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7157 {
7158 if (!wxPyCheckForApp()) SWIG_fail;
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (wxWindow *)wxGetActiveWindow();
7161 wxPyEndAllowThreads(__tstate);
7162 if (PyErr_Occurred()) SWIG_fail;
7163 }
7164 {
7165 resultobj = wxPyMake_wxObject(result, 0);
7166 }
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7174 PyObject *resultobj = 0;
7175 wxPoint *arg1 = 0 ;
7176 wxWindow *result = 0 ;
7177 wxPoint temp1 ;
7178 PyObject * obj0 = 0 ;
7179 char * kwnames[] = {
7180 (char *) "pt", NULL
7181 };
7182
7183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7184 {
7185 arg1 = &temp1;
7186 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7187 }
7188 {
7189 if (!wxPyCheckForApp()) SWIG_fail;
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 {
7196 resultobj = wxPyMake_wxObject(result, 0);
7197 }
7198 return resultobj;
7199 fail:
7200 return NULL;
7201 }
7202
7203
7204 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7205 PyObject *resultobj = 0;
7206 wxPoint *arg1 = 0 ;
7207 wxWindow *result = 0 ;
7208 wxPoint temp1 ;
7209 PyObject * obj0 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "pt", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7215 {
7216 arg1 = &temp1;
7217 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7218 }
7219 {
7220 if (!wxPyCheckForApp()) SWIG_fail;
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7223 wxPyEndAllowThreads(__tstate);
7224 if (PyErr_Occurred()) SWIG_fail;
7225 }
7226 {
7227 resultobj = wxPyMake_wxObject(result, 0);
7228 }
7229 return resultobj;
7230 fail:
7231 return NULL;
7232 }
7233
7234
7235 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7236 PyObject *resultobj = 0;
7237 wxWindow *arg1 = (wxWindow *) 0 ;
7238 wxWindow *result = 0 ;
7239 void *argp1 = 0 ;
7240 int res1 = 0 ;
7241 PyObject * obj0 = 0 ;
7242 char * kwnames[] = {
7243 (char *) "win", NULL
7244 };
7245
7246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7248 if (!SWIG_IsOK(res1)) {
7249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7250 }
7251 arg1 = reinterpret_cast< wxWindow * >(argp1);
7252 {
7253 if (!wxPyCheckForApp()) SWIG_fail;
7254 PyThreadState* __tstate = wxPyBeginAllowThreads();
7255 result = (wxWindow *)wxGetTopLevelParent(arg1);
7256 wxPyEndAllowThreads(__tstate);
7257 if (PyErr_Occurred()) SWIG_fail;
7258 }
7259 {
7260 resultobj = wxPyMake_wxObject(result, 0);
7261 }
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7269 PyObject *resultobj = 0;
7270 wxString *arg1 = 0 ;
7271 bool result;
7272 bool temp1 = false ;
7273 PyObject * obj0 = 0 ;
7274 char * kwnames[] = {
7275 (char *) "url", NULL
7276 };
7277
7278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7279 {
7280 arg1 = wxString_in_helper(obj0);
7281 if (arg1 == NULL) SWIG_fail;
7282 temp1 = true;
7283 }
7284 {
7285 PyThreadState* __tstate = wxPyBeginAllowThreads();
7286 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7287 wxPyEndAllowThreads(__tstate);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 {
7291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7292 }
7293 {
7294 if (temp1)
7295 delete arg1;
7296 }
7297 return resultobj;
7298 fail:
7299 {
7300 if (temp1)
7301 delete arg1;
7302 }
7303 return NULL;
7304 }
7305
7306
7307 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj = 0;
7309 wxKeyCode arg1 ;
7310 bool result;
7311 int val1 ;
7312 int ecode1 = 0 ;
7313 PyObject * obj0 = 0 ;
7314 char * kwnames[] = {
7315 (char *) "key", NULL
7316 };
7317
7318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7319 ecode1 = SWIG_AsVal_int(obj0, &val1);
7320 if (!SWIG_IsOK(ecode1)) {
7321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7322 }
7323 arg1 = static_cast< wxKeyCode >(val1);
7324 {
7325 if (!wxPyCheckForApp()) SWIG_fail;
7326 PyThreadState* __tstate = wxPyBeginAllowThreads();
7327 result = (bool)wxGetKeyState(arg1);
7328 wxPyEndAllowThreads(__tstate);
7329 if (PyErr_Occurred()) SWIG_fail;
7330 }
7331 {
7332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7333 }
7334 return resultobj;
7335 fail:
7336 return NULL;
7337 }
7338
7339
7340 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7341 PyObject *resultobj = 0;
7342 wxMouseState *result = 0 ;
7343
7344 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7345 {
7346 PyThreadState* __tstate = wxPyBeginAllowThreads();
7347 result = (wxMouseState *)new wxMouseState();
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7359 PyObject *resultobj = 0;
7360 wxMouseState *arg1 = (wxMouseState *) 0 ;
7361 void *argp1 = 0 ;
7362 int res1 = 0 ;
7363 PyObject *swig_obj[1] ;
7364
7365 if (!args) SWIG_fail;
7366 swig_obj[0] = args;
7367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7370 }
7371 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7372 {
7373 PyThreadState* __tstate = wxPyBeginAllowThreads();
7374 delete arg1;
7375
7376 wxPyEndAllowThreads(__tstate);
7377 if (PyErr_Occurred()) SWIG_fail;
7378 }
7379 resultobj = SWIG_Py_Void();
7380 return resultobj;
7381 fail:
7382 return NULL;
7383 }
7384
7385
7386 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7387 PyObject *resultobj = 0;
7388 wxMouseState *arg1 = (wxMouseState *) 0 ;
7389 int result;
7390 void *argp1 = 0 ;
7391 int res1 = 0 ;
7392 PyObject *swig_obj[1] ;
7393
7394 if (!args) SWIG_fail;
7395 swig_obj[0] = args;
7396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7399 }
7400 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 result = (int)(arg1)->GetX();
7404 wxPyEndAllowThreads(__tstate);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 resultobj = SWIG_From_int(static_cast< int >(result));
7408 return resultobj;
7409 fail:
7410 return NULL;
7411 }
7412
7413
7414 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7415 PyObject *resultobj = 0;
7416 wxMouseState *arg1 = (wxMouseState *) 0 ;
7417 int result;
7418 void *argp1 = 0 ;
7419 int res1 = 0 ;
7420 PyObject *swig_obj[1] ;
7421
7422 if (!args) SWIG_fail;
7423 swig_obj[0] = args;
7424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7425 if (!SWIG_IsOK(res1)) {
7426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7427 }
7428 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7429 {
7430 PyThreadState* __tstate = wxPyBeginAllowThreads();
7431 result = (int)(arg1)->GetY();
7432 wxPyEndAllowThreads(__tstate);
7433 if (PyErr_Occurred()) SWIG_fail;
7434 }
7435 resultobj = SWIG_From_int(static_cast< int >(result));
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7443 PyObject *resultobj = 0;
7444 wxMouseState *arg1 = (wxMouseState *) 0 ;
7445 bool result;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 PyObject *swig_obj[1] ;
7449
7450 if (!args) SWIG_fail;
7451 swig_obj[0] = args;
7452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7453 if (!SWIG_IsOK(res1)) {
7454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7455 }
7456 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = (bool)(arg1)->LeftDown();
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 {
7464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7465 }
7466 return resultobj;
7467 fail:
7468 return NULL;
7469 }
7470
7471
7472 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7473 PyObject *resultobj = 0;
7474 wxMouseState *arg1 = (wxMouseState *) 0 ;
7475 bool result;
7476 void *argp1 = 0 ;
7477 int res1 = 0 ;
7478 PyObject *swig_obj[1] ;
7479
7480 if (!args) SWIG_fail;
7481 swig_obj[0] = args;
7482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7485 }
7486 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (bool)(arg1)->MiddleDown();
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 {
7494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495 }
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7503 PyObject *resultobj = 0;
7504 wxMouseState *arg1 = (wxMouseState *) 0 ;
7505 bool result;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 PyObject *swig_obj[1] ;
7509
7510 if (!args) SWIG_fail;
7511 swig_obj[0] = args;
7512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7513 if (!SWIG_IsOK(res1)) {
7514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7515 }
7516 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (bool)(arg1)->RightDown();
7520 wxPyEndAllowThreads(__tstate);
7521 if (PyErr_Occurred()) SWIG_fail;
7522 }
7523 {
7524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7525 }
7526 return resultobj;
7527 fail:
7528 return NULL;
7529 }
7530
7531
7532 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7533 PyObject *resultobj = 0;
7534 wxMouseState *arg1 = (wxMouseState *) 0 ;
7535 bool result;
7536 void *argp1 = 0 ;
7537 int res1 = 0 ;
7538 PyObject *swig_obj[1] ;
7539
7540 if (!args) SWIG_fail;
7541 swig_obj[0] = args;
7542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7543 if (!SWIG_IsOK(res1)) {
7544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7545 }
7546 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7547 {
7548 PyThreadState* __tstate = wxPyBeginAllowThreads();
7549 result = (bool)(arg1)->ControlDown();
7550 wxPyEndAllowThreads(__tstate);
7551 if (PyErr_Occurred()) SWIG_fail;
7552 }
7553 {
7554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7555 }
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7563 PyObject *resultobj = 0;
7564 wxMouseState *arg1 = (wxMouseState *) 0 ;
7565 bool result;
7566 void *argp1 = 0 ;
7567 int res1 = 0 ;
7568 PyObject *swig_obj[1] ;
7569
7570 if (!args) SWIG_fail;
7571 swig_obj[0] = args;
7572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7573 if (!SWIG_IsOK(res1)) {
7574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7575 }
7576 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7577 {
7578 PyThreadState* __tstate = wxPyBeginAllowThreads();
7579 result = (bool)(arg1)->ShiftDown();
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7585 }
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7593 PyObject *resultobj = 0;
7594 wxMouseState *arg1 = (wxMouseState *) 0 ;
7595 bool result;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 PyObject *swig_obj[1] ;
7599
7600 if (!args) SWIG_fail;
7601 swig_obj[0] = args;
7602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7603 if (!SWIG_IsOK(res1)) {
7604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7605 }
7606 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7607 {
7608 PyThreadState* __tstate = wxPyBeginAllowThreads();
7609 result = (bool)(arg1)->AltDown();
7610 wxPyEndAllowThreads(__tstate);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7623 PyObject *resultobj = 0;
7624 wxMouseState *arg1 = (wxMouseState *) 0 ;
7625 bool result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 PyObject *swig_obj[1] ;
7629
7630 if (!args) SWIG_fail;
7631 swig_obj[0] = args;
7632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7633 if (!SWIG_IsOK(res1)) {
7634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7635 }
7636 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 result = (bool)(arg1)->MetaDown();
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 {
7644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7645 }
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7653 PyObject *resultobj = 0;
7654 wxMouseState *arg1 = (wxMouseState *) 0 ;
7655 bool result;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 PyObject *swig_obj[1] ;
7659
7660 if (!args) SWIG_fail;
7661 swig_obj[0] = args;
7662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7665 }
7666 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 result = (bool)(arg1)->CmdDown();
7670 wxPyEndAllowThreads(__tstate);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 {
7674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7675 }
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj = 0;
7684 wxMouseState *arg1 = (wxMouseState *) 0 ;
7685 int arg2 ;
7686 void *argp1 = 0 ;
7687 int res1 = 0 ;
7688 int val2 ;
7689 int ecode2 = 0 ;
7690 PyObject * obj0 = 0 ;
7691 PyObject * obj1 = 0 ;
7692 char * kwnames[] = {
7693 (char *) "self",(char *) "x", NULL
7694 };
7695
7696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7698 if (!SWIG_IsOK(res1)) {
7699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7700 }
7701 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7702 ecode2 = SWIG_AsVal_int(obj1, &val2);
7703 if (!SWIG_IsOK(ecode2)) {
7704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7705 }
7706 arg2 = static_cast< int >(val2);
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 (arg1)->SetX(arg2);
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 resultobj = SWIG_Py_Void();
7714 return resultobj;
7715 fail:
7716 return NULL;
7717 }
7718
7719
7720 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7721 PyObject *resultobj = 0;
7722 wxMouseState *arg1 = (wxMouseState *) 0 ;
7723 int arg2 ;
7724 void *argp1 = 0 ;
7725 int res1 = 0 ;
7726 int val2 ;
7727 int ecode2 = 0 ;
7728 PyObject * obj0 = 0 ;
7729 PyObject * obj1 = 0 ;
7730 char * kwnames[] = {
7731 (char *) "self",(char *) "y", NULL
7732 };
7733
7734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7736 if (!SWIG_IsOK(res1)) {
7737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7738 }
7739 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7740 ecode2 = SWIG_AsVal_int(obj1, &val2);
7741 if (!SWIG_IsOK(ecode2)) {
7742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7743 }
7744 arg2 = static_cast< int >(val2);
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 (arg1)->SetY(arg2);
7748 wxPyEndAllowThreads(__tstate);
7749 if (PyErr_Occurred()) SWIG_fail;
7750 }
7751 resultobj = SWIG_Py_Void();
7752 return resultobj;
7753 fail:
7754 return NULL;
7755 }
7756
7757
7758 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7759 PyObject *resultobj = 0;
7760 wxMouseState *arg1 = (wxMouseState *) 0 ;
7761 bool arg2 ;
7762 void *argp1 = 0 ;
7763 int res1 = 0 ;
7764 bool val2 ;
7765 int ecode2 = 0 ;
7766 PyObject * obj0 = 0 ;
7767 PyObject * obj1 = 0 ;
7768 char * kwnames[] = {
7769 (char *) "self",(char *) "down", NULL
7770 };
7771
7772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7774 if (!SWIG_IsOK(res1)) {
7775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7776 }
7777 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7778 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7779 if (!SWIG_IsOK(ecode2)) {
7780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7781 }
7782 arg2 = static_cast< bool >(val2);
7783 {
7784 PyThreadState* __tstate = wxPyBeginAllowThreads();
7785 (arg1)->SetLeftDown(arg2);
7786 wxPyEndAllowThreads(__tstate);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 resultobj = SWIG_Py_Void();
7790 return resultobj;
7791 fail:
7792 return NULL;
7793 }
7794
7795
7796 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7797 PyObject *resultobj = 0;
7798 wxMouseState *arg1 = (wxMouseState *) 0 ;
7799 bool arg2 ;
7800 void *argp1 = 0 ;
7801 int res1 = 0 ;
7802 bool val2 ;
7803 int ecode2 = 0 ;
7804 PyObject * obj0 = 0 ;
7805 PyObject * obj1 = 0 ;
7806 char * kwnames[] = {
7807 (char *) "self",(char *) "down", NULL
7808 };
7809
7810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7812 if (!SWIG_IsOK(res1)) {
7813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7814 }
7815 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7816 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7817 if (!SWIG_IsOK(ecode2)) {
7818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7819 }
7820 arg2 = static_cast< bool >(val2);
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 (arg1)->SetMiddleDown(arg2);
7824 wxPyEndAllowThreads(__tstate);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 resultobj = SWIG_Py_Void();
7828 return resultobj;
7829 fail:
7830 return NULL;
7831 }
7832
7833
7834 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7835 PyObject *resultobj = 0;
7836 wxMouseState *arg1 = (wxMouseState *) 0 ;
7837 bool arg2 ;
7838 void *argp1 = 0 ;
7839 int res1 = 0 ;
7840 bool val2 ;
7841 int ecode2 = 0 ;
7842 PyObject * obj0 = 0 ;
7843 PyObject * obj1 = 0 ;
7844 char * kwnames[] = {
7845 (char *) "self",(char *) "down", NULL
7846 };
7847
7848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7850 if (!SWIG_IsOK(res1)) {
7851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7852 }
7853 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7854 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7855 if (!SWIG_IsOK(ecode2)) {
7856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7857 }
7858 arg2 = static_cast< bool >(val2);
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 (arg1)->SetRightDown(arg2);
7862 wxPyEndAllowThreads(__tstate);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 resultobj = SWIG_Py_Void();
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj = 0;
7874 wxMouseState *arg1 = (wxMouseState *) 0 ;
7875 bool arg2 ;
7876 void *argp1 = 0 ;
7877 int res1 = 0 ;
7878 bool val2 ;
7879 int ecode2 = 0 ;
7880 PyObject * obj0 = 0 ;
7881 PyObject * obj1 = 0 ;
7882 char * kwnames[] = {
7883 (char *) "self",(char *) "down", NULL
7884 };
7885
7886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7890 }
7891 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7893 if (!SWIG_IsOK(ecode2)) {
7894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7895 }
7896 arg2 = static_cast< bool >(val2);
7897 {
7898 PyThreadState* __tstate = wxPyBeginAllowThreads();
7899 (arg1)->SetControlDown(arg2);
7900 wxPyEndAllowThreads(__tstate);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 resultobj = SWIG_Py_Void();
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7911 PyObject *resultobj = 0;
7912 wxMouseState *arg1 = (wxMouseState *) 0 ;
7913 bool arg2 ;
7914 void *argp1 = 0 ;
7915 int res1 = 0 ;
7916 bool val2 ;
7917 int ecode2 = 0 ;
7918 PyObject * obj0 = 0 ;
7919 PyObject * obj1 = 0 ;
7920 char * kwnames[] = {
7921 (char *) "self",(char *) "down", NULL
7922 };
7923
7924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7926 if (!SWIG_IsOK(res1)) {
7927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7928 }
7929 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7931 if (!SWIG_IsOK(ecode2)) {
7932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7933 }
7934 arg2 = static_cast< bool >(val2);
7935 {
7936 PyThreadState* __tstate = wxPyBeginAllowThreads();
7937 (arg1)->SetShiftDown(arg2);
7938 wxPyEndAllowThreads(__tstate);
7939 if (PyErr_Occurred()) SWIG_fail;
7940 }
7941 resultobj = SWIG_Py_Void();
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7949 PyObject *resultobj = 0;
7950 wxMouseState *arg1 = (wxMouseState *) 0 ;
7951 bool arg2 ;
7952 void *argp1 = 0 ;
7953 int res1 = 0 ;
7954 bool val2 ;
7955 int ecode2 = 0 ;
7956 PyObject * obj0 = 0 ;
7957 PyObject * obj1 = 0 ;
7958 char * kwnames[] = {
7959 (char *) "self",(char *) "down", NULL
7960 };
7961
7962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7964 if (!SWIG_IsOK(res1)) {
7965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7966 }
7967 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7969 if (!SWIG_IsOK(ecode2)) {
7970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7971 }
7972 arg2 = static_cast< bool >(val2);
7973 {
7974 PyThreadState* __tstate = wxPyBeginAllowThreads();
7975 (arg1)->SetAltDown(arg2);
7976 wxPyEndAllowThreads(__tstate);
7977 if (PyErr_Occurred()) SWIG_fail;
7978 }
7979 resultobj = SWIG_Py_Void();
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7987 PyObject *resultobj = 0;
7988 wxMouseState *arg1 = (wxMouseState *) 0 ;
7989 bool arg2 ;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 bool val2 ;
7993 int ecode2 = 0 ;
7994 PyObject * obj0 = 0 ;
7995 PyObject * obj1 = 0 ;
7996 char * kwnames[] = {
7997 (char *) "self",(char *) "down", NULL
7998 };
7999
8000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
8001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
8002 if (!SWIG_IsOK(res1)) {
8003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
8004 }
8005 arg1 = reinterpret_cast< wxMouseState * >(argp1);
8006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
8007 if (!SWIG_IsOK(ecode2)) {
8008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8009 }
8010 arg2 = static_cast< bool >(val2);
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 (arg1)->SetMetaDown(arg2);
8014 wxPyEndAllowThreads(__tstate);
8015 if (PyErr_Occurred()) SWIG_fail;
8016 }
8017 resultobj = SWIG_Py_Void();
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 PyObject *obj;
8026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8027 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8028 return SWIG_Py_Void();
8029 }
8030
8031 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8032 return SWIG_Python_InitShadowInstance(args);
8033 }
8034
8035 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8036 PyObject *resultobj = 0;
8037 wxMouseState result;
8038
8039 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8040 {
8041 PyThreadState* __tstate = wxPyBeginAllowThreads();
8042 result = wxGetMouseState();
8043 wxPyEndAllowThreads(__tstate);
8044 if (PyErr_Occurred()) SWIG_fail;
8045 }
8046 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055
8056 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8057 {
8058 if (!wxPyCheckForApp()) SWIG_fail;
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 wxWakeUpMainThread();
8061 wxPyEndAllowThreads(__tstate);
8062 if (PyErr_Occurred()) SWIG_fail;
8063 }
8064 resultobj = SWIG_Py_Void();
8065 return resultobj;
8066 fail:
8067 return NULL;
8068 }
8069
8070
8071 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8072 PyObject *resultobj = 0;
8073
8074 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8075 {
8076 if (!wxPyCheckForApp()) SWIG_fail;
8077 PyThreadState* __tstate = wxPyBeginAllowThreads();
8078 wxMutexGuiEnter();
8079 wxPyEndAllowThreads(__tstate);
8080 if (PyErr_Occurred()) SWIG_fail;
8081 }
8082 resultobj = SWIG_Py_Void();
8083 return resultobj;
8084 fail:
8085 return NULL;
8086 }
8087
8088
8089 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8090 PyObject *resultobj = 0;
8091
8092 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8093 {
8094 if (!wxPyCheckForApp()) SWIG_fail;
8095 PyThreadState* __tstate = wxPyBeginAllowThreads();
8096 wxMutexGuiLeave();
8097 wxPyEndAllowThreads(__tstate);
8098 if (PyErr_Occurred()) SWIG_fail;
8099 }
8100 resultobj = SWIG_Py_Void();
8101 return resultobj;
8102 fail:
8103 return NULL;
8104 }
8105
8106
8107 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8108 PyObject *resultobj = 0;
8109 wxMutexGuiLocker *result = 0 ;
8110
8111 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8112 {
8113 if (!wxPyCheckForApp()) SWIG_fail;
8114 PyThreadState* __tstate = wxPyBeginAllowThreads();
8115 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8116 wxPyEndAllowThreads(__tstate);
8117 if (PyErr_Occurred()) SWIG_fail;
8118 }
8119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8120 return resultobj;
8121 fail:
8122 return NULL;
8123 }
8124
8125
8126 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8127 PyObject *resultobj = 0;
8128 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8129 void *argp1 = 0 ;
8130 int res1 = 0 ;
8131 PyObject *swig_obj[1] ;
8132
8133 if (!args) SWIG_fail;
8134 swig_obj[0] = args;
8135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8136 if (!SWIG_IsOK(res1)) {
8137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8138 }
8139 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 delete arg1;
8143
8144 wxPyEndAllowThreads(__tstate);
8145 if (PyErr_Occurred()) SWIG_fail;
8146 }
8147 resultobj = SWIG_Py_Void();
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8155 PyObject *obj;
8156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8157 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8158 return SWIG_Py_Void();
8159 }
8160
8161 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8162 return SWIG_Python_InitShadowInstance(args);
8163 }
8164
8165 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8166 PyObject *resultobj = 0;
8167 bool result;
8168
8169 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8170 {
8171 PyThreadState* __tstate = wxPyBeginAllowThreads();
8172 result = (bool)wxThread_IsMain();
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 {
8177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8178 }
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj = 0;
8187 wxString *arg1 = 0 ;
8188 wxToolTip *result = 0 ;
8189 bool temp1 = false ;
8190 PyObject * obj0 = 0 ;
8191 char * kwnames[] = {
8192 (char *) "tip", NULL
8193 };
8194
8195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8196 {
8197 arg1 = wxString_in_helper(obj0);
8198 if (arg1 == NULL) SWIG_fail;
8199 temp1 = true;
8200 }
8201 {
8202 if (!wxPyCheckForApp()) SWIG_fail;
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8209 {
8210 if (temp1)
8211 delete arg1;
8212 }
8213 return resultobj;
8214 fail:
8215 {
8216 if (temp1)
8217 delete arg1;
8218 }
8219 return NULL;
8220 }
8221
8222
8223 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8224 PyObject *resultobj = 0;
8225 wxToolTip *arg1 = (wxToolTip *) 0 ;
8226 void *argp1 = 0 ;
8227 int res1 = 0 ;
8228 PyObject *swig_obj[1] ;
8229
8230 if (!args) SWIG_fail;
8231 swig_obj[0] = args;
8232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8233 if (!SWIG_IsOK(res1)) {
8234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8235 }
8236 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8237 {
8238 PyThreadState* __tstate = wxPyBeginAllowThreads();
8239 delete arg1;
8240
8241 wxPyEndAllowThreads(__tstate);
8242 if (PyErr_Occurred()) SWIG_fail;
8243 }
8244 resultobj = SWIG_Py_Void();
8245 return resultobj;
8246 fail:
8247 return NULL;
8248 }
8249
8250
8251 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8252 PyObject *resultobj = 0;
8253 wxToolTip *arg1 = (wxToolTip *) 0 ;
8254 wxString *arg2 = 0 ;
8255 void *argp1 = 0 ;
8256 int res1 = 0 ;
8257 bool temp2 = false ;
8258 PyObject * obj0 = 0 ;
8259 PyObject * obj1 = 0 ;
8260 char * kwnames[] = {
8261 (char *) "self",(char *) "tip", NULL
8262 };
8263
8264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8266 if (!SWIG_IsOK(res1)) {
8267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8268 }
8269 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8270 {
8271 arg2 = wxString_in_helper(obj1);
8272 if (arg2 == NULL) SWIG_fail;
8273 temp2 = true;
8274 }
8275 {
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 (arg1)->SetTip((wxString const &)*arg2);
8278 wxPyEndAllowThreads(__tstate);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 resultobj = SWIG_Py_Void();
8282 {
8283 if (temp2)
8284 delete arg2;
8285 }
8286 return resultobj;
8287 fail:
8288 {
8289 if (temp2)
8290 delete arg2;
8291 }
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8297 PyObject *resultobj = 0;
8298 wxToolTip *arg1 = (wxToolTip *) 0 ;
8299 wxString result;
8300 void *argp1 = 0 ;
8301 int res1 = 0 ;
8302 PyObject *swig_obj[1] ;
8303
8304 if (!args) SWIG_fail;
8305 swig_obj[0] = args;
8306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8307 if (!SWIG_IsOK(res1)) {
8308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8309 }
8310 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (arg1)->GetTip();
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 {
8318 #if wxUSE_UNICODE
8319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8320 #else
8321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8322 #endif
8323 }
8324 return resultobj;
8325 fail:
8326 return NULL;
8327 }
8328
8329
8330 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8331 PyObject *resultobj = 0;
8332 wxToolTip *arg1 = (wxToolTip *) 0 ;
8333 wxWindow *result = 0 ;
8334 void *argp1 = 0 ;
8335 int res1 = 0 ;
8336 PyObject *swig_obj[1] ;
8337
8338 if (!args) SWIG_fail;
8339 swig_obj[0] = args;
8340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8341 if (!SWIG_IsOK(res1)) {
8342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8343 }
8344 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8345 {
8346 PyThreadState* __tstate = wxPyBeginAllowThreads();
8347 result = (wxWindow *)(arg1)->GetWindow();
8348 wxPyEndAllowThreads(__tstate);
8349 if (PyErr_Occurred()) SWIG_fail;
8350 }
8351 {
8352 resultobj = wxPyMake_wxObject(result, 0);
8353 }
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 bool arg1 ;
8363 bool val1 ;
8364 int ecode1 = 0 ;
8365 PyObject * obj0 = 0 ;
8366 char * kwnames[] = {
8367 (char *) "flag", NULL
8368 };
8369
8370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8371 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8372 if (!SWIG_IsOK(ecode1)) {
8373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8374 }
8375 arg1 = static_cast< bool >(val1);
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 wxToolTip::Enable(arg1);
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 resultobj = SWIG_Py_Void();
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj = 0;
8391 long arg1 ;
8392 long val1 ;
8393 int ecode1 = 0 ;
8394 PyObject * obj0 = 0 ;
8395 char * kwnames[] = {
8396 (char *) "milliseconds", NULL
8397 };
8398
8399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8400 ecode1 = SWIG_AsVal_long(obj0, &val1);
8401 if (!SWIG_IsOK(ecode1)) {
8402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8403 }
8404 arg1 = static_cast< long >(val1);
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 wxToolTip::SetDelay(arg1);
8408 wxPyEndAllowThreads(__tstate);
8409 if (PyErr_Occurred()) SWIG_fail;
8410 }
8411 resultobj = SWIG_Py_Void();
8412 return resultobj;
8413 fail:
8414 return NULL;
8415 }
8416
8417
8418 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8419 PyObject *obj;
8420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8421 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8422 return SWIG_Py_Void();
8423 }
8424
8425 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8426 return SWIG_Python_InitShadowInstance(args);
8427 }
8428
8429 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8430 PyObject *resultobj = 0;
8431 wxWindow *arg1 = (wxWindow *) 0 ;
8432 wxSize *arg2 = 0 ;
8433 wxCaret *result = 0 ;
8434 void *argp1 = 0 ;
8435 int res1 = 0 ;
8436 wxSize temp2 ;
8437 PyObject * obj0 = 0 ;
8438 PyObject * obj1 = 0 ;
8439 char * kwnames[] = {
8440 (char *) "window",(char *) "size", NULL
8441 };
8442
8443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8445 if (!SWIG_IsOK(res1)) {
8446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8447 }
8448 arg1 = reinterpret_cast< wxWindow * >(argp1);
8449 {
8450 arg2 = &temp2;
8451 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8452 }
8453 {
8454 if (!wxPyCheckForApp()) SWIG_fail;
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8457 wxPyEndAllowThreads(__tstate);
8458 if (PyErr_Occurred()) SWIG_fail;
8459 }
8460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8468 PyObject *resultobj = 0;
8469 wxCaret *arg1 = (wxCaret *) 0 ;
8470 void *argp1 = 0 ;
8471 int res1 = 0 ;
8472 PyObject *swig_obj[1] ;
8473
8474 if (!args) SWIG_fail;
8475 swig_obj[0] = args;
8476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8477 if (!SWIG_IsOK(res1)) {
8478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8479 }
8480 arg1 = reinterpret_cast< wxCaret * >(argp1);
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 delete arg1;
8484
8485 wxPyEndAllowThreads(__tstate);
8486 if (PyErr_Occurred()) SWIG_fail;
8487 }
8488 resultobj = SWIG_Py_Void();
8489 return resultobj;
8490 fail:
8491 return NULL;
8492 }
8493
8494
8495 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8496 PyObject *resultobj = 0;
8497 wxCaret *arg1 = (wxCaret *) 0 ;
8498 void *argp1 = 0 ;
8499 int res1 = 0 ;
8500 PyObject *swig_obj[1] ;
8501
8502 if (!args) SWIG_fail;
8503 swig_obj[0] = args;
8504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8505 if (!SWIG_IsOK(res1)) {
8506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8507 }
8508 arg1 = reinterpret_cast< wxCaret * >(argp1);
8509 {
8510 PyThreadState* __tstate = wxPyBeginAllowThreads();
8511 wxCaret_Destroy(arg1);
8512 wxPyEndAllowThreads(__tstate);
8513 if (PyErr_Occurred()) SWIG_fail;
8514 }
8515 resultobj = SWIG_Py_Void();
8516 return resultobj;
8517 fail:
8518 return NULL;
8519 }
8520
8521
8522 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8523 PyObject *resultobj = 0;
8524 wxCaret *arg1 = (wxCaret *) 0 ;
8525 bool result;
8526 void *argp1 = 0 ;
8527 int res1 = 0 ;
8528 PyObject *swig_obj[1] ;
8529
8530 if (!args) SWIG_fail;
8531 swig_obj[0] = args;
8532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8533 if (!SWIG_IsOK(res1)) {
8534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8535 }
8536 arg1 = reinterpret_cast< wxCaret * >(argp1);
8537 {
8538 PyThreadState* __tstate = wxPyBeginAllowThreads();
8539 result = (bool)(arg1)->IsOk();
8540 wxPyEndAllowThreads(__tstate);
8541 if (PyErr_Occurred()) SWIG_fail;
8542 }
8543 {
8544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8545 }
8546 return resultobj;
8547 fail:
8548 return NULL;
8549 }
8550
8551
8552 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8553 PyObject *resultobj = 0;
8554 wxCaret *arg1 = (wxCaret *) 0 ;
8555 bool result;
8556 void *argp1 = 0 ;
8557 int res1 = 0 ;
8558 PyObject *swig_obj[1] ;
8559
8560 if (!args) SWIG_fail;
8561 swig_obj[0] = args;
8562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8565 }
8566 arg1 = reinterpret_cast< wxCaret * >(argp1);
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 result = (bool)(arg1)->IsVisible();
8570 wxPyEndAllowThreads(__tstate);
8571 if (PyErr_Occurred()) SWIG_fail;
8572 }
8573 {
8574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8575 }
8576 return resultobj;
8577 fail:
8578 return NULL;
8579 }
8580
8581
8582 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8583 PyObject *resultobj = 0;
8584 wxCaret *arg1 = (wxCaret *) 0 ;
8585 wxPoint result;
8586 void *argp1 = 0 ;
8587 int res1 = 0 ;
8588 PyObject *swig_obj[1] ;
8589
8590 if (!args) SWIG_fail;
8591 swig_obj[0] = args;
8592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8595 }
8596 arg1 = reinterpret_cast< wxCaret * >(argp1);
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 result = (arg1)->GetPosition();
8600 wxPyEndAllowThreads(__tstate);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8611 PyObject *resultobj = 0;
8612 wxCaret *arg1 = (wxCaret *) 0 ;
8613 int *arg2 = (int *) 0 ;
8614 int *arg3 = (int *) 0 ;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 int temp2 ;
8618 int res2 = SWIG_TMPOBJ ;
8619 int temp3 ;
8620 int res3 = SWIG_TMPOBJ ;
8621 PyObject *swig_obj[1] ;
8622
8623 arg2 = &temp2;
8624 arg3 = &temp3;
8625 if (!args) SWIG_fail;
8626 swig_obj[0] = args;
8627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8630 }
8631 arg1 = reinterpret_cast< wxCaret * >(argp1);
8632 {
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 (arg1)->GetPosition(arg2,arg3);
8635 wxPyEndAllowThreads(__tstate);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 resultobj = SWIG_Py_Void();
8639 if (SWIG_IsTmpObj(res2)) {
8640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8641 } else {
8642 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8644 }
8645 if (SWIG_IsTmpObj(res3)) {
8646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8647 } else {
8648 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8650 }
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8658 PyObject *resultobj = 0;
8659 wxCaret *arg1 = (wxCaret *) 0 ;
8660 wxSize result;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 PyObject *swig_obj[1] ;
8664
8665 if (!args) SWIG_fail;
8666 swig_obj[0] = args;
8667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8668 if (!SWIG_IsOK(res1)) {
8669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8670 }
8671 arg1 = reinterpret_cast< wxCaret * >(argp1);
8672 {
8673 PyThreadState* __tstate = wxPyBeginAllowThreads();
8674 result = (arg1)->GetSize();
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8679 return resultobj;
8680 fail:
8681 return NULL;
8682 }
8683
8684
8685 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8686 PyObject *resultobj = 0;
8687 wxCaret *arg1 = (wxCaret *) 0 ;
8688 int *arg2 = (int *) 0 ;
8689 int *arg3 = (int *) 0 ;
8690 void *argp1 = 0 ;
8691 int res1 = 0 ;
8692 int temp2 ;
8693 int res2 = SWIG_TMPOBJ ;
8694 int temp3 ;
8695 int res3 = SWIG_TMPOBJ ;
8696 PyObject *swig_obj[1] ;
8697
8698 arg2 = &temp2;
8699 arg3 = &temp3;
8700 if (!args) SWIG_fail;
8701 swig_obj[0] = args;
8702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8703 if (!SWIG_IsOK(res1)) {
8704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8705 }
8706 arg1 = reinterpret_cast< wxCaret * >(argp1);
8707 {
8708 PyThreadState* __tstate = wxPyBeginAllowThreads();
8709 (arg1)->GetSize(arg2,arg3);
8710 wxPyEndAllowThreads(__tstate);
8711 if (PyErr_Occurred()) SWIG_fail;
8712 }
8713 resultobj = SWIG_Py_Void();
8714 if (SWIG_IsTmpObj(res2)) {
8715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8716 } else {
8717 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8719 }
8720 if (SWIG_IsTmpObj(res3)) {
8721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8722 } else {
8723 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8725 }
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8733 PyObject *resultobj = 0;
8734 wxCaret *arg1 = (wxCaret *) 0 ;
8735 wxWindow *result = 0 ;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 PyObject *swig_obj[1] ;
8739
8740 if (!args) SWIG_fail;
8741 swig_obj[0] = args;
8742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8743 if (!SWIG_IsOK(res1)) {
8744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8745 }
8746 arg1 = reinterpret_cast< wxCaret * >(argp1);
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 result = (wxWindow *)(arg1)->GetWindow();
8750 wxPyEndAllowThreads(__tstate);
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 {
8754 resultobj = wxPyMake_wxObject(result, 0);
8755 }
8756 return resultobj;
8757 fail:
8758 return NULL;
8759 }
8760
8761
8762 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8763 PyObject *resultobj = 0;
8764 wxCaret *arg1 = (wxCaret *) 0 ;
8765 int arg2 ;
8766 int arg3 ;
8767 void *argp1 = 0 ;
8768 int res1 = 0 ;
8769 int val2 ;
8770 int ecode2 = 0 ;
8771 int val3 ;
8772 int ecode3 = 0 ;
8773 PyObject * obj0 = 0 ;
8774 PyObject * obj1 = 0 ;
8775 PyObject * obj2 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "self",(char *) "x",(char *) "y", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8784 }
8785 arg1 = reinterpret_cast< wxCaret * >(argp1);
8786 ecode2 = SWIG_AsVal_int(obj1, &val2);
8787 if (!SWIG_IsOK(ecode2)) {
8788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8789 }
8790 arg2 = static_cast< int >(val2);
8791 ecode3 = SWIG_AsVal_int(obj2, &val3);
8792 if (!SWIG_IsOK(ecode3)) {
8793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8794 }
8795 arg3 = static_cast< int >(val3);
8796 {
8797 PyThreadState* __tstate = wxPyBeginAllowThreads();
8798 (arg1)->Move(arg2,arg3);
8799 wxPyEndAllowThreads(__tstate);
8800 if (PyErr_Occurred()) SWIG_fail;
8801 }
8802 resultobj = SWIG_Py_Void();
8803 return resultobj;
8804 fail:
8805 return NULL;
8806 }
8807
8808
8809 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8810 PyObject *resultobj = 0;
8811 wxCaret *arg1 = (wxCaret *) 0 ;
8812 wxPoint *arg2 = 0 ;
8813 void *argp1 = 0 ;
8814 int res1 = 0 ;
8815 wxPoint temp2 ;
8816 PyObject * obj0 = 0 ;
8817 PyObject * obj1 = 0 ;
8818 char * kwnames[] = {
8819 (char *) "self",(char *) "pt", NULL
8820 };
8821
8822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8824 if (!SWIG_IsOK(res1)) {
8825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8826 }
8827 arg1 = reinterpret_cast< wxCaret * >(argp1);
8828 {
8829 arg2 = &temp2;
8830 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8831 }
8832 {
8833 PyThreadState* __tstate = wxPyBeginAllowThreads();
8834 (arg1)->Move((wxPoint const &)*arg2);
8835 wxPyEndAllowThreads(__tstate);
8836 if (PyErr_Occurred()) SWIG_fail;
8837 }
8838 resultobj = SWIG_Py_Void();
8839 return resultobj;
8840 fail:
8841 return NULL;
8842 }
8843
8844
8845 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8846 PyObject *resultobj = 0;
8847 wxCaret *arg1 = (wxCaret *) 0 ;
8848 int arg2 ;
8849 int arg3 ;
8850 void *argp1 = 0 ;
8851 int res1 = 0 ;
8852 int val2 ;
8853 int ecode2 = 0 ;
8854 int val3 ;
8855 int ecode3 = 0 ;
8856 PyObject * obj0 = 0 ;
8857 PyObject * obj1 = 0 ;
8858 PyObject * obj2 = 0 ;
8859 char * kwnames[] = {
8860 (char *) "self",(char *) "width",(char *) "height", NULL
8861 };
8862
8863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8865 if (!SWIG_IsOK(res1)) {
8866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8867 }
8868 arg1 = reinterpret_cast< wxCaret * >(argp1);
8869 ecode2 = SWIG_AsVal_int(obj1, &val2);
8870 if (!SWIG_IsOK(ecode2)) {
8871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8872 }
8873 arg2 = static_cast< int >(val2);
8874 ecode3 = SWIG_AsVal_int(obj2, &val3);
8875 if (!SWIG_IsOK(ecode3)) {
8876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8877 }
8878 arg3 = static_cast< int >(val3);
8879 {
8880 PyThreadState* __tstate = wxPyBeginAllowThreads();
8881 (arg1)->SetSize(arg2,arg3);
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_Py_Void();
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj = 0;
8894 wxCaret *arg1 = (wxCaret *) 0 ;
8895 wxSize *arg2 = 0 ;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 wxSize temp2 ;
8899 PyObject * obj0 = 0 ;
8900 PyObject * obj1 = 0 ;
8901 char * kwnames[] = {
8902 (char *) "self",(char *) "size", NULL
8903 };
8904
8905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8907 if (!SWIG_IsOK(res1)) {
8908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8909 }
8910 arg1 = reinterpret_cast< wxCaret * >(argp1);
8911 {
8912 arg2 = &temp2;
8913 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8914 }
8915 {
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 (arg1)->SetSize((wxSize const &)*arg2);
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 resultobj = SWIG_Py_Void();
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8929 PyObject *resultobj = 0;
8930 wxCaret *arg1 = (wxCaret *) 0 ;
8931 int arg2 = (int) true ;
8932 void *argp1 = 0 ;
8933 int res1 = 0 ;
8934 int val2 ;
8935 int ecode2 = 0 ;
8936 PyObject * obj0 = 0 ;
8937 PyObject * obj1 = 0 ;
8938 char * kwnames[] = {
8939 (char *) "self",(char *) "show", NULL
8940 };
8941
8942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8944 if (!SWIG_IsOK(res1)) {
8945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8946 }
8947 arg1 = reinterpret_cast< wxCaret * >(argp1);
8948 if (obj1) {
8949 ecode2 = SWIG_AsVal_int(obj1, &val2);
8950 if (!SWIG_IsOK(ecode2)) {
8951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8952 }
8953 arg2 = static_cast< int >(val2);
8954 }
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 (arg1)->Show(arg2);
8958 wxPyEndAllowThreads(__tstate);
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 resultobj = SWIG_Py_Void();
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8969 PyObject *resultobj = 0;
8970 wxCaret *arg1 = (wxCaret *) 0 ;
8971 void *argp1 = 0 ;
8972 int res1 = 0 ;
8973 PyObject *swig_obj[1] ;
8974
8975 if (!args) SWIG_fail;
8976 swig_obj[0] = args;
8977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8978 if (!SWIG_IsOK(res1)) {
8979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8980 }
8981 arg1 = reinterpret_cast< wxCaret * >(argp1);
8982 {
8983 PyThreadState* __tstate = wxPyBeginAllowThreads();
8984 (arg1)->Hide();
8985 wxPyEndAllowThreads(__tstate);
8986 if (PyErr_Occurred()) SWIG_fail;
8987 }
8988 resultobj = SWIG_Py_Void();
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 int result;
8998
8999 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
9000 {
9001 PyThreadState* __tstate = wxPyBeginAllowThreads();
9002 result = (int)wxCaret::GetBlinkTime();
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 resultobj = SWIG_From_int(static_cast< int >(result));
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj = 0;
9015 int arg1 ;
9016 int val1 ;
9017 int ecode1 = 0 ;
9018 PyObject * obj0 = 0 ;
9019 char * kwnames[] = {
9020 (char *) "milliseconds", NULL
9021 };
9022
9023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9024 ecode1 = SWIG_AsVal_int(obj0, &val1);
9025 if (!SWIG_IsOK(ecode1)) {
9026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9027 }
9028 arg1 = static_cast< int >(val1);
9029 {
9030 PyThreadState* __tstate = wxPyBeginAllowThreads();
9031 wxCaret::SetBlinkTime(arg1);
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 resultobj = SWIG_Py_Void();
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9043 PyObject *obj;
9044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9045 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9046 return SWIG_Py_Void();
9047 }
9048
9049 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9050 return SWIG_Python_InitShadowInstance(args);
9051 }
9052
9053 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9054 PyObject *resultobj = 0;
9055 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9056 wxBusyCursor *result = 0 ;
9057 void *argp1 = 0 ;
9058 int res1 = 0 ;
9059 PyObject * obj0 = 0 ;
9060 char * kwnames[] = {
9061 (char *) "cursor", NULL
9062 };
9063
9064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9065 if (obj0) {
9066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9067 if (!SWIG_IsOK(res1)) {
9068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9069 }
9070 arg1 = reinterpret_cast< wxCursor * >(argp1);
9071 }
9072 {
9073 if (!wxPyCheckForApp()) SWIG_fail;
9074 PyThreadState* __tstate = wxPyBeginAllowThreads();
9075 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9076 wxPyEndAllowThreads(__tstate);
9077 if (PyErr_Occurred()) SWIG_fail;
9078 }
9079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9087 PyObject *resultobj = 0;
9088 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9089 void *argp1 = 0 ;
9090 int res1 = 0 ;
9091 PyObject *swig_obj[1] ;
9092
9093 if (!args) SWIG_fail;
9094 swig_obj[0] = args;
9095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9096 if (!SWIG_IsOK(res1)) {
9097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9098 }
9099 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 delete arg1;
9103
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_Py_Void();
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 PyObject *obj;
9116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9117 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9118 return SWIG_Py_Void();
9119 }
9120
9121 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9122 return SWIG_Python_InitShadowInstance(args);
9123 }
9124
9125 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj = 0;
9127 wxWindow *arg1 = (wxWindow *) NULL ;
9128 wxWindowDisabler *result = 0 ;
9129 void *argp1 = 0 ;
9130 int res1 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 char * kwnames[] = {
9133 (char *) "winToSkip", NULL
9134 };
9135
9136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9137 if (obj0) {
9138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9139 if (!SWIG_IsOK(res1)) {
9140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9141 }
9142 arg1 = reinterpret_cast< wxWindow * >(argp1);
9143 }
9144 {
9145 if (!wxPyCheckForApp()) SWIG_fail;
9146 PyThreadState* __tstate = wxPyBeginAllowThreads();
9147 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9148 wxPyEndAllowThreads(__tstate);
9149 if (PyErr_Occurred()) SWIG_fail;
9150 }
9151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9159 PyObject *resultobj = 0;
9160 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9161 void *argp1 = 0 ;
9162 int res1 = 0 ;
9163 PyObject *swig_obj[1] ;
9164
9165 if (!args) SWIG_fail;
9166 swig_obj[0] = args;
9167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9168 if (!SWIG_IsOK(res1)) {
9169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9170 }
9171 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 delete arg1;
9175
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 resultobj = SWIG_Py_Void();
9180 return resultobj;
9181 fail:
9182 return NULL;
9183 }
9184
9185
9186 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9187 PyObject *obj;
9188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9189 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9190 return SWIG_Py_Void();
9191 }
9192
9193 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9194 return SWIG_Python_InitShadowInstance(args);
9195 }
9196
9197 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj = 0;
9199 wxString *arg1 = 0 ;
9200 wxWindow *arg2 = (wxWindow *) NULL ;
9201 wxBusyInfo *result = 0 ;
9202 bool temp1 = false ;
9203 void *argp2 = 0 ;
9204 int res2 = 0 ;
9205 PyObject * obj0 = 0 ;
9206 PyObject * obj1 = 0 ;
9207 char * kwnames[] = {
9208 (char *) "message",(char *) "parent", NULL
9209 };
9210
9211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_BusyInfo",kwnames,&obj0,&obj1)) SWIG_fail;
9212 {
9213 arg1 = wxString_in_helper(obj0);
9214 if (arg1 == NULL) SWIG_fail;
9215 temp1 = true;
9216 }
9217 if (obj1) {
9218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
9219 if (!SWIG_IsOK(res2)) {
9220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BusyInfo" "', expected argument " "2"" of type '" "wxWindow *""'");
9221 }
9222 arg2 = reinterpret_cast< wxWindow * >(argp2);
9223 }
9224 {
9225 if (!wxPyCheckForApp()) SWIG_fail;
9226 PyThreadState* __tstate = wxPyBeginAllowThreads();
9227 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1,arg2);
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9232 {
9233 if (temp1)
9234 delete arg1;
9235 }
9236 return resultobj;
9237 fail:
9238 {
9239 if (temp1)
9240 delete arg1;
9241 }
9242 return NULL;
9243 }
9244
9245
9246 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9247 PyObject *resultobj = 0;
9248 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9249 void *argp1 = 0 ;
9250 int res1 = 0 ;
9251 PyObject *swig_obj[1] ;
9252
9253 if (!args) SWIG_fail;
9254 swig_obj[0] = args;
9255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9256 if (!SWIG_IsOK(res1)) {
9257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9258 }
9259 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9260 {
9261 PyThreadState* __tstate = wxPyBeginAllowThreads();
9262 delete arg1;
9263
9264 wxPyEndAllowThreads(__tstate);
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 resultobj = SWIG_Py_Void();
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 PyObject *obj;
9276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9277 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9278 return SWIG_Py_Void();
9279 }
9280
9281 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9282 return SWIG_Python_InitShadowInstance(args);
9283 }
9284
9285 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9286 PyObject *resultobj = 0;
9287 wxStopWatch *result = 0 ;
9288
9289 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9290 {
9291 PyThreadState* __tstate = wxPyBeginAllowThreads();
9292 result = (wxStopWatch *)new wxStopWatch();
9293 wxPyEndAllowThreads(__tstate);
9294 if (PyErr_Occurred()) SWIG_fail;
9295 }
9296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9304 PyObject *resultobj = 0;
9305 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9306 void *argp1 = 0 ;
9307 int res1 = 0 ;
9308 PyObject *swig_obj[1] ;
9309
9310 if (!args) SWIG_fail;
9311 swig_obj[0] = args;
9312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9313 if (!SWIG_IsOK(res1)) {
9314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9315 }
9316 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9317 {
9318 PyThreadState* __tstate = wxPyBeginAllowThreads();
9319 delete arg1;
9320
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9332 PyObject *resultobj = 0;
9333 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9334 long arg2 = (long) 0 ;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 long val2 ;
9338 int ecode2 = 0 ;
9339 PyObject * obj0 = 0 ;
9340 PyObject * obj1 = 0 ;
9341 char * kwnames[] = {
9342 (char *) "self",(char *) "t0", NULL
9343 };
9344
9345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9347 if (!SWIG_IsOK(res1)) {
9348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9349 }
9350 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9351 if (obj1) {
9352 ecode2 = SWIG_AsVal_long(obj1, &val2);
9353 if (!SWIG_IsOK(ecode2)) {
9354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9355 }
9356 arg2 = static_cast< long >(val2);
9357 }
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 (arg1)->Start(arg2);
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 resultobj = SWIG_Py_Void();
9365 return resultobj;
9366 fail:
9367 return NULL;
9368 }
9369
9370
9371 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9372 PyObject *resultobj = 0;
9373 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 PyObject *swig_obj[1] ;
9377
9378 if (!args) SWIG_fail;
9379 swig_obj[0] = args;
9380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9381 if (!SWIG_IsOK(res1)) {
9382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9383 }
9384 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9385 {
9386 PyThreadState* __tstate = wxPyBeginAllowThreads();
9387 (arg1)->Pause();
9388 wxPyEndAllowThreads(__tstate);
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 resultobj = SWIG_Py_Void();
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9399 PyObject *resultobj = 0;
9400 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 PyObject *swig_obj[1] ;
9404
9405 if (!args) SWIG_fail;
9406 swig_obj[0] = args;
9407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9408 if (!SWIG_IsOK(res1)) {
9409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9410 }
9411 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9412 {
9413 PyThreadState* __tstate = wxPyBeginAllowThreads();
9414 (arg1)->Resume();
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_Py_Void();
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9426 PyObject *resultobj = 0;
9427 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9428 long result;
9429 void *argp1 = 0 ;
9430 int res1 = 0 ;
9431 PyObject *swig_obj[1] ;
9432
9433 if (!args) SWIG_fail;
9434 swig_obj[0] = args;
9435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9436 if (!SWIG_IsOK(res1)) {
9437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9438 }
9439 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (long)((wxStopWatch const *)arg1)->Time();
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = SWIG_From_long(static_cast< long >(result));
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9454 PyObject *obj;
9455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9456 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9457 return SWIG_Py_Void();
9458 }
9459
9460 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9461 return SWIG_Python_InitShadowInstance(args);
9462 }
9463
9464 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9465 PyObject *resultobj = 0;
9466 int arg1 = (int) 9 ;
9467 int arg2 = (int) wxID_FILE1 ;
9468 wxFileHistory *result = 0 ;
9469 int val1 ;
9470 int ecode1 = 0 ;
9471 int val2 ;
9472 int ecode2 = 0 ;
9473 PyObject * obj0 = 0 ;
9474 PyObject * obj1 = 0 ;
9475 char * kwnames[] = {
9476 (char *) "maxFiles",(char *) "idBase", NULL
9477 };
9478
9479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9480 if (obj0) {
9481 ecode1 = SWIG_AsVal_int(obj0, &val1);
9482 if (!SWIG_IsOK(ecode1)) {
9483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9484 }
9485 arg1 = static_cast< int >(val1);
9486 }
9487 if (obj1) {
9488 ecode2 = SWIG_AsVal_int(obj1, &val2);
9489 if (!SWIG_IsOK(ecode2)) {
9490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9491 }
9492 arg2 = static_cast< int >(val2);
9493 }
9494 {
9495 PyThreadState* __tstate = wxPyBeginAllowThreads();
9496 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9497 wxPyEndAllowThreads(__tstate);
9498 if (PyErr_Occurred()) SWIG_fail;
9499 }
9500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9501 return resultobj;
9502 fail:
9503 return NULL;
9504 }
9505
9506
9507 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9508 PyObject *resultobj = 0;
9509 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9510 void *argp1 = 0 ;
9511 int res1 = 0 ;
9512 PyObject *swig_obj[1] ;
9513
9514 if (!args) SWIG_fail;
9515 swig_obj[0] = args;
9516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9517 if (!SWIG_IsOK(res1)) {
9518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9519 }
9520 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9521 {
9522 PyThreadState* __tstate = wxPyBeginAllowThreads();
9523 delete arg1;
9524
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 resultobj = SWIG_Py_Void();
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj = 0;
9537 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9538 wxString *arg2 = 0 ;
9539 void *argp1 = 0 ;
9540 int res1 = 0 ;
9541 bool temp2 = false ;
9542 PyObject * obj0 = 0 ;
9543 PyObject * obj1 = 0 ;
9544 char * kwnames[] = {
9545 (char *) "self",(char *) "file", NULL
9546 };
9547
9548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9550 if (!SWIG_IsOK(res1)) {
9551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9552 }
9553 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9554 {
9555 arg2 = wxString_in_helper(obj1);
9556 if (arg2 == NULL) SWIG_fail;
9557 temp2 = true;
9558 }
9559 {
9560 PyThreadState* __tstate = wxPyBeginAllowThreads();
9561 (arg1)->AddFileToHistory((wxString const &)*arg2);
9562 wxPyEndAllowThreads(__tstate);
9563 if (PyErr_Occurred()) SWIG_fail;
9564 }
9565 resultobj = SWIG_Py_Void();
9566 {
9567 if (temp2)
9568 delete arg2;
9569 }
9570 return resultobj;
9571 fail:
9572 {
9573 if (temp2)
9574 delete arg2;
9575 }
9576 return NULL;
9577 }
9578
9579
9580 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9581 PyObject *resultobj = 0;
9582 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9583 int arg2 ;
9584 void *argp1 = 0 ;
9585 int res1 = 0 ;
9586 int val2 ;
9587 int ecode2 = 0 ;
9588 PyObject * obj0 = 0 ;
9589 PyObject * obj1 = 0 ;
9590 char * kwnames[] = {
9591 (char *) "self",(char *) "i", NULL
9592 };
9593
9594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9596 if (!SWIG_IsOK(res1)) {
9597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9598 }
9599 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9600 ecode2 = SWIG_AsVal_int(obj1, &val2);
9601 if (!SWIG_IsOK(ecode2)) {
9602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9603 }
9604 arg2 = static_cast< int >(val2);
9605 {
9606 PyThreadState* __tstate = wxPyBeginAllowThreads();
9607 (arg1)->RemoveFileFromHistory(arg2);
9608 wxPyEndAllowThreads(__tstate);
9609 if (PyErr_Occurred()) SWIG_fail;
9610 }
9611 resultobj = SWIG_Py_Void();
9612 return resultobj;
9613 fail:
9614 return NULL;
9615 }
9616
9617
9618 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9619 PyObject *resultobj = 0;
9620 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9621 int result;
9622 void *argp1 = 0 ;
9623 int res1 = 0 ;
9624 PyObject *swig_obj[1] ;
9625
9626 if (!args) SWIG_fail;
9627 swig_obj[0] = args;
9628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9629 if (!SWIG_IsOK(res1)) {
9630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9631 }
9632 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9633 {
9634 PyThreadState* __tstate = wxPyBeginAllowThreads();
9635 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 resultobj = SWIG_From_int(static_cast< int >(result));
9640 return resultobj;
9641 fail:
9642 return NULL;
9643 }
9644
9645
9646 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9647 PyObject *resultobj = 0;
9648 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9649 wxMenu *arg2 = (wxMenu *) 0 ;
9650 void *argp1 = 0 ;
9651 int res1 = 0 ;
9652 void *argp2 = 0 ;
9653 int res2 = 0 ;
9654 PyObject * obj0 = 0 ;
9655 PyObject * obj1 = 0 ;
9656 char * kwnames[] = {
9657 (char *) "self",(char *) "menu", NULL
9658 };
9659
9660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9662 if (!SWIG_IsOK(res1)) {
9663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9664 }
9665 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9667 if (!SWIG_IsOK(res2)) {
9668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9669 }
9670 arg2 = reinterpret_cast< wxMenu * >(argp2);
9671 {
9672 PyThreadState* __tstate = wxPyBeginAllowThreads();
9673 (arg1)->UseMenu(arg2);
9674 wxPyEndAllowThreads(__tstate);
9675 if (PyErr_Occurred()) SWIG_fail;
9676 }
9677 resultobj = SWIG_Py_Void();
9678 return resultobj;
9679 fail:
9680 return NULL;
9681 }
9682
9683
9684 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9685 PyObject *resultobj = 0;
9686 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9687 wxMenu *arg2 = (wxMenu *) 0 ;
9688 void *argp1 = 0 ;
9689 int res1 = 0 ;
9690 void *argp2 = 0 ;
9691 int res2 = 0 ;
9692 PyObject * obj0 = 0 ;
9693 PyObject * obj1 = 0 ;
9694 char * kwnames[] = {
9695 (char *) "self",(char *) "menu", NULL
9696 };
9697
9698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9700 if (!SWIG_IsOK(res1)) {
9701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9702 }
9703 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9705 if (!SWIG_IsOK(res2)) {
9706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9707 }
9708 arg2 = reinterpret_cast< wxMenu * >(argp2);
9709 {
9710 PyThreadState* __tstate = wxPyBeginAllowThreads();
9711 (arg1)->RemoveMenu(arg2);
9712 wxPyEndAllowThreads(__tstate);
9713 if (PyErr_Occurred()) SWIG_fail;
9714 }
9715 resultobj = SWIG_Py_Void();
9716 return resultobj;
9717 fail:
9718 return NULL;
9719 }
9720
9721
9722 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj = 0;
9724 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9725 wxConfigBase *arg2 = 0 ;
9726 void *argp1 = 0 ;
9727 int res1 = 0 ;
9728 void *argp2 = 0 ;
9729 int res2 = 0 ;
9730 PyObject * obj0 = 0 ;
9731 PyObject * obj1 = 0 ;
9732 char * kwnames[] = {
9733 (char *) "self",(char *) "config", NULL
9734 };
9735
9736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9738 if (!SWIG_IsOK(res1)) {
9739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9740 }
9741 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9743 if (!SWIG_IsOK(res2)) {
9744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9745 }
9746 if (!argp2) {
9747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9748 }
9749 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9750 {
9751 PyThreadState* __tstate = wxPyBeginAllowThreads();
9752 (arg1)->Load(*arg2);
9753 wxPyEndAllowThreads(__tstate);
9754 if (PyErr_Occurred()) SWIG_fail;
9755 }
9756 resultobj = SWIG_Py_Void();
9757 return resultobj;
9758 fail:
9759 return NULL;
9760 }
9761
9762
9763 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9764 PyObject *resultobj = 0;
9765 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9766 wxConfigBase *arg2 = 0 ;
9767 void *argp1 = 0 ;
9768 int res1 = 0 ;
9769 void *argp2 = 0 ;
9770 int res2 = 0 ;
9771 PyObject * obj0 = 0 ;
9772 PyObject * obj1 = 0 ;
9773 char * kwnames[] = {
9774 (char *) "self",(char *) "config", NULL
9775 };
9776
9777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9779 if (!SWIG_IsOK(res1)) {
9780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9781 }
9782 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9784 if (!SWIG_IsOK(res2)) {
9785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9786 }
9787 if (!argp2) {
9788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9789 }
9790 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9791 {
9792 PyThreadState* __tstate = wxPyBeginAllowThreads();
9793 (arg1)->Save(*arg2);
9794 wxPyEndAllowThreads(__tstate);
9795 if (PyErr_Occurred()) SWIG_fail;
9796 }
9797 resultobj = SWIG_Py_Void();
9798 return resultobj;
9799 fail:
9800 return NULL;
9801 }
9802
9803
9804 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9805 PyObject *resultobj = 0;
9806 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9807 void *argp1 = 0 ;
9808 int res1 = 0 ;
9809 PyObject *swig_obj[1] ;
9810
9811 if (!args) SWIG_fail;
9812 swig_obj[0] = args;
9813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9814 if (!SWIG_IsOK(res1)) {
9815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9816 }
9817 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 (arg1)->AddFilesToMenu();
9821 wxPyEndAllowThreads(__tstate);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 resultobj = SWIG_Py_Void();
9825 return resultobj;
9826 fail:
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9832 PyObject *resultobj = 0;
9833 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9834 wxMenu *arg2 = (wxMenu *) 0 ;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 void *argp2 = 0 ;
9838 int res2 = 0 ;
9839 PyObject * obj0 = 0 ;
9840 PyObject * obj1 = 0 ;
9841 char * kwnames[] = {
9842 (char *) "self",(char *) "menu", NULL
9843 };
9844
9845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9847 if (!SWIG_IsOK(res1)) {
9848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9849 }
9850 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9851 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9852 if (!SWIG_IsOK(res2)) {
9853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9854 }
9855 arg2 = reinterpret_cast< wxMenu * >(argp2);
9856 {
9857 PyThreadState* __tstate = wxPyBeginAllowThreads();
9858 (arg1)->AddFilesToMenu(arg2);
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 resultobj = SWIG_Py_Void();
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj = 0;
9871 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9872 int arg2 ;
9873 wxString result;
9874 void *argp1 = 0 ;
9875 int res1 = 0 ;
9876 int val2 ;
9877 int ecode2 = 0 ;
9878 PyObject * obj0 = 0 ;
9879 PyObject * obj1 = 0 ;
9880 char * kwnames[] = {
9881 (char *) "self",(char *) "i", NULL
9882 };
9883
9884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9886 if (!SWIG_IsOK(res1)) {
9887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9888 }
9889 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9890 ecode2 = SWIG_AsVal_int(obj1, &val2);
9891 if (!SWIG_IsOK(ecode2)) {
9892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9893 }
9894 arg2 = static_cast< int >(val2);
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9898 wxPyEndAllowThreads(__tstate);
9899 if (PyErr_Occurred()) SWIG_fail;
9900 }
9901 {
9902 #if wxUSE_UNICODE
9903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9904 #else
9905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9906 #endif
9907 }
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9915 PyObject *resultobj = 0;
9916 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9917 int result;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 PyObject *swig_obj[1] ;
9921
9922 if (!args) SWIG_fail;
9923 swig_obj[0] = args;
9924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9925 if (!SWIG_IsOK(res1)) {
9926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9927 }
9928 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 result = (int)((wxFileHistory const *)arg1)->GetCount();
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 resultobj = SWIG_From_int(static_cast< int >(result));
9936 return resultobj;
9937 fail:
9938 return NULL;
9939 }
9940
9941
9942 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9943 PyObject *obj;
9944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9945 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9946 return SWIG_Py_Void();
9947 }
9948
9949 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9950 return SWIG_Python_InitShadowInstance(args);
9951 }
9952
9953 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj = 0;
9955 wxString *arg1 = 0 ;
9956 wxString const &arg2_defvalue = wxPyEmptyString ;
9957 wxString *arg2 = (wxString *) &arg2_defvalue ;
9958 wxSingleInstanceChecker *result = 0 ;
9959 bool temp1 = false ;
9960 bool temp2 = false ;
9961 PyObject * obj0 = 0 ;
9962 PyObject * obj1 = 0 ;
9963 char * kwnames[] = {
9964 (char *) "name",(char *) "path", NULL
9965 };
9966
9967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9968 {
9969 arg1 = wxString_in_helper(obj0);
9970 if (arg1 == NULL) SWIG_fail;
9971 temp1 = true;
9972 }
9973 if (obj1) {
9974 {
9975 arg2 = wxString_in_helper(obj1);
9976 if (arg2 == NULL) SWIG_fail;
9977 temp2 = true;
9978 }
9979 }
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9987 {
9988 if (temp1)
9989 delete arg1;
9990 }
9991 {
9992 if (temp2)
9993 delete arg2;
9994 }
9995 return resultobj;
9996 fail:
9997 {
9998 if (temp1)
9999 delete arg1;
10000 }
10001 {
10002 if (temp2)
10003 delete arg2;
10004 }
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10010 PyObject *resultobj = 0;
10011 wxSingleInstanceChecker *result = 0 ;
10012
10013 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10017 wxPyEndAllowThreads(__tstate);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *resultobj = 0;
10029 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10030 void *argp1 = 0 ;
10031 int res1 = 0 ;
10032 PyObject *swig_obj[1] ;
10033
10034 if (!args) SWIG_fail;
10035 swig_obj[0] = args;
10036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10037 if (!SWIG_IsOK(res1)) {
10038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10039 }
10040 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10041 {
10042 PyThreadState* __tstate = wxPyBeginAllowThreads();
10043 delete arg1;
10044
10045 wxPyEndAllowThreads(__tstate);
10046 if (PyErr_Occurred()) SWIG_fail;
10047 }
10048 resultobj = SWIG_Py_Void();
10049 return resultobj;
10050 fail:
10051 return NULL;
10052 }
10053
10054
10055 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj = 0;
10057 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10058 wxString *arg2 = 0 ;
10059 wxString const &arg3_defvalue = wxPyEmptyString ;
10060 wxString *arg3 = (wxString *) &arg3_defvalue ;
10061 bool result;
10062 void *argp1 = 0 ;
10063 int res1 = 0 ;
10064 bool temp2 = false ;
10065 bool temp3 = false ;
10066 PyObject * obj0 = 0 ;
10067 PyObject * obj1 = 0 ;
10068 PyObject * obj2 = 0 ;
10069 char * kwnames[] = {
10070 (char *) "self",(char *) "name",(char *) "path", NULL
10071 };
10072
10073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10075 if (!SWIG_IsOK(res1)) {
10076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10077 }
10078 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10079 {
10080 arg2 = wxString_in_helper(obj1);
10081 if (arg2 == NULL) SWIG_fail;
10082 temp2 = true;
10083 }
10084 if (obj2) {
10085 {
10086 arg3 = wxString_in_helper(obj2);
10087 if (arg3 == NULL) SWIG_fail;
10088 temp3 = true;
10089 }
10090 }
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10094 wxPyEndAllowThreads(__tstate);
10095 if (PyErr_Occurred()) SWIG_fail;
10096 }
10097 {
10098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10099 }
10100 {
10101 if (temp2)
10102 delete arg2;
10103 }
10104 {
10105 if (temp3)
10106 delete arg3;
10107 }
10108 return resultobj;
10109 fail:
10110 {
10111 if (temp2)
10112 delete arg2;
10113 }
10114 {
10115 if (temp3)
10116 delete arg3;
10117 }
10118 return NULL;
10119 }
10120
10121
10122 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10123 PyObject *resultobj = 0;
10124 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10125 bool result;
10126 void *argp1 = 0 ;
10127 int res1 = 0 ;
10128 PyObject *swig_obj[1] ;
10129
10130 if (!args) SWIG_fail;
10131 swig_obj[0] = args;
10132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10133 if (!SWIG_IsOK(res1)) {
10134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10135 }
10136 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10137 {
10138 PyThreadState* __tstate = wxPyBeginAllowThreads();
10139 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 {
10144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10145 }
10146 return resultobj;
10147 fail:
10148 return NULL;
10149 }
10150
10151
10152 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10153 PyObject *obj;
10154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10155 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10156 return SWIG_Py_Void();
10157 }
10158
10159 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10160 return SWIG_Python_InitShadowInstance(args);
10161 }
10162
10163 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10164 PyObject *resultobj = 0;
10165 wxPlatformInfo *result = 0 ;
10166
10167 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10168 {
10169 PyThreadState* __tstate = wxPyBeginAllowThreads();
10170 result = (wxPlatformInfo *)new wxPlatformInfo();
10171 wxPyEndAllowThreads(__tstate);
10172 if (PyErr_Occurred()) SWIG_fail;
10173 }
10174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10182 PyObject *resultobj = 0;
10183 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10184 wxPlatformInfo *arg2 = 0 ;
10185 bool result;
10186 void *argp1 = 0 ;
10187 int res1 = 0 ;
10188 void *argp2 = 0 ;
10189 int res2 = 0 ;
10190 PyObject * obj0 = 0 ;
10191 PyObject * obj1 = 0 ;
10192 char * kwnames[] = {
10193 (char *) "self",(char *) "t", NULL
10194 };
10195
10196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10198 if (!SWIG_IsOK(res1)) {
10199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10200 }
10201 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10203 if (!SWIG_IsOK(res2)) {
10204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10205 }
10206 if (!argp2) {
10207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10208 }
10209 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10213 wxPyEndAllowThreads(__tstate);
10214 if (PyErr_Occurred()) SWIG_fail;
10215 }
10216 {
10217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10218 }
10219 return resultobj;
10220 fail:
10221 return NULL;
10222 }
10223
10224
10225 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10226 PyObject *resultobj = 0;
10227 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10228 wxPlatformInfo *arg2 = 0 ;
10229 bool result;
10230 void *argp1 = 0 ;
10231 int res1 = 0 ;
10232 void *argp2 = 0 ;
10233 int res2 = 0 ;
10234 PyObject * obj0 = 0 ;
10235 PyObject * obj1 = 0 ;
10236 char * kwnames[] = {
10237 (char *) "self",(char *) "t", NULL
10238 };
10239
10240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10242 if (!SWIG_IsOK(res1)) {
10243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10244 }
10245 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10246 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10247 if (!SWIG_IsOK(res2)) {
10248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10249 }
10250 if (!argp2) {
10251 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10252 }
10253 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 {
10261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10262 }
10263 return resultobj;
10264 fail:
10265 return NULL;
10266 }
10267
10268
10269 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10270 PyObject *resultobj = 0;
10271 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10272 int result;
10273 void *argp1 = 0 ;
10274 int res1 = 0 ;
10275 PyObject *swig_obj[1] ;
10276
10277 if (!args) SWIG_fail;
10278 swig_obj[0] = args;
10279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10280 if (!SWIG_IsOK(res1)) {
10281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10282 }
10283 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10284 {
10285 PyThreadState* __tstate = wxPyBeginAllowThreads();
10286 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10287 wxPyEndAllowThreads(__tstate);
10288 if (PyErr_Occurred()) SWIG_fail;
10289 }
10290 resultobj = SWIG_From_int(static_cast< int >(result));
10291 return resultobj;
10292 fail:
10293 return NULL;
10294 }
10295
10296
10297 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10298 PyObject *resultobj = 0;
10299 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10300 int result;
10301 void *argp1 = 0 ;
10302 int res1 = 0 ;
10303 PyObject *swig_obj[1] ;
10304
10305 if (!args) SWIG_fail;
10306 swig_obj[0] = args;
10307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10308 if (!SWIG_IsOK(res1)) {
10309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10310 }
10311 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10315 wxPyEndAllowThreads(__tstate);
10316 if (PyErr_Occurred()) SWIG_fail;
10317 }
10318 resultobj = SWIG_From_int(static_cast< int >(result));
10319 return resultobj;
10320 fail:
10321 return NULL;
10322 }
10323
10324
10325 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10326 PyObject *resultobj = 0;
10327 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10328 int arg2 ;
10329 int arg3 ;
10330 bool result;
10331 void *argp1 = 0 ;
10332 int res1 = 0 ;
10333 int val2 ;
10334 int ecode2 = 0 ;
10335 int val3 ;
10336 int ecode3 = 0 ;
10337 PyObject * obj0 = 0 ;
10338 PyObject * obj1 = 0 ;
10339 PyObject * obj2 = 0 ;
10340 char * kwnames[] = {
10341 (char *) "self",(char *) "major",(char *) "minor", NULL
10342 };
10343
10344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10346 if (!SWIG_IsOK(res1)) {
10347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10348 }
10349 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10350 ecode2 = SWIG_AsVal_int(obj1, &val2);
10351 if (!SWIG_IsOK(ecode2)) {
10352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10353 }
10354 arg2 = static_cast< int >(val2);
10355 ecode3 = SWIG_AsVal_int(obj2, &val3);
10356 if (!SWIG_IsOK(ecode3)) {
10357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10358 }
10359 arg3 = static_cast< int >(val3);
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 {
10367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10368 }
10369 return resultobj;
10370 fail:
10371 return NULL;
10372 }
10373
10374
10375 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10376 PyObject *resultobj = 0;
10377 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10378 int result;
10379 void *argp1 = 0 ;
10380 int res1 = 0 ;
10381 PyObject *swig_obj[1] ;
10382
10383 if (!args) SWIG_fail;
10384 swig_obj[0] = args;
10385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10386 if (!SWIG_IsOK(res1)) {
10387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10388 }
10389 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10390 {
10391 PyThreadState* __tstate = wxPyBeginAllowThreads();
10392 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10393 wxPyEndAllowThreads(__tstate);
10394 if (PyErr_Occurred()) SWIG_fail;
10395 }
10396 resultobj = SWIG_From_int(static_cast< int >(result));
10397 return resultobj;
10398 fail:
10399 return NULL;
10400 }
10401
10402
10403 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10404 PyObject *resultobj = 0;
10405 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10406 int result;
10407 void *argp1 = 0 ;
10408 int res1 = 0 ;
10409 PyObject *swig_obj[1] ;
10410
10411 if (!args) SWIG_fail;
10412 swig_obj[0] = args;
10413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10414 if (!SWIG_IsOK(res1)) {
10415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10416 }
10417 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10418 {
10419 PyThreadState* __tstate = wxPyBeginAllowThreads();
10420 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10421 wxPyEndAllowThreads(__tstate);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 resultobj = SWIG_From_int(static_cast< int >(result));
10425 return resultobj;
10426 fail:
10427 return NULL;
10428 }
10429
10430
10431 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10432 PyObject *resultobj = 0;
10433 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10434 int arg2 ;
10435 int arg3 ;
10436 bool result;
10437 void *argp1 = 0 ;
10438 int res1 = 0 ;
10439 int val2 ;
10440 int ecode2 = 0 ;
10441 int val3 ;
10442 int ecode3 = 0 ;
10443 PyObject * obj0 = 0 ;
10444 PyObject * obj1 = 0 ;
10445 PyObject * obj2 = 0 ;
10446 char * kwnames[] = {
10447 (char *) "self",(char *) "major",(char *) "minor", NULL
10448 };
10449
10450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10452 if (!SWIG_IsOK(res1)) {
10453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10454 }
10455 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10456 ecode2 = SWIG_AsVal_int(obj1, &val2);
10457 if (!SWIG_IsOK(ecode2)) {
10458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10459 }
10460 arg2 = static_cast< int >(val2);
10461 ecode3 = SWIG_AsVal_int(obj2, &val3);
10462 if (!SWIG_IsOK(ecode3)) {
10463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10464 }
10465 arg3 = static_cast< int >(val3);
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 {
10473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10474 }
10475 return resultobj;
10476 fail:
10477 return NULL;
10478 }
10479
10480
10481 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10482 PyObject *resultobj = 0;
10483 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10484 bool result;
10485 void *argp1 = 0 ;
10486 int res1 = 0 ;
10487 PyObject *swig_obj[1] ;
10488
10489 if (!args) SWIG_fail;
10490 swig_obj[0] = args;
10491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10492 if (!SWIG_IsOK(res1)) {
10493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10494 }
10495 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10496 {
10497 PyThreadState* __tstate = wxPyBeginAllowThreads();
10498 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10499 wxPyEndAllowThreads(__tstate);
10500 if (PyErr_Occurred()) SWIG_fail;
10501 }
10502 {
10503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10504 }
10505 return resultobj;
10506 fail:
10507 return NULL;
10508 }
10509
10510
10511 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10512 PyObject *resultobj = 0;
10513 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10514 wxOperatingSystemId result;
10515 void *argp1 = 0 ;
10516 int res1 = 0 ;
10517 PyObject *swig_obj[1] ;
10518
10519 if (!args) SWIG_fail;
10520 swig_obj[0] = args;
10521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10522 if (!SWIG_IsOK(res1)) {
10523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10524 }
10525 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 resultobj = SWIG_From_int(static_cast< int >(result));
10533 return resultobj;
10534 fail:
10535 return NULL;
10536 }
10537
10538
10539 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10540 PyObject *resultobj = 0;
10541 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10542 wxPortId result;
10543 void *argp1 = 0 ;
10544 int res1 = 0 ;
10545 PyObject *swig_obj[1] ;
10546
10547 if (!args) SWIG_fail;
10548 swig_obj[0] = args;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10552 }
10553 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 resultobj = SWIG_From_int(static_cast< int >(result));
10561 return resultobj;
10562 fail:
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *resultobj = 0;
10569 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10570 wxArchitecture result;
10571 void *argp1 = 0 ;
10572 int res1 = 0 ;
10573 PyObject *swig_obj[1] ;
10574
10575 if (!args) SWIG_fail;
10576 swig_obj[0] = args;
10577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10578 if (!SWIG_IsOK(res1)) {
10579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10580 }
10581 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10582 {
10583 PyThreadState* __tstate = wxPyBeginAllowThreads();
10584 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 resultobj = SWIG_From_int(static_cast< int >(result));
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10596 PyObject *resultobj = 0;
10597 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10598 wxEndianness result;
10599 void *argp1 = 0 ;
10600 int res1 = 0 ;
10601 PyObject *swig_obj[1] ;
10602
10603 if (!args) SWIG_fail;
10604 swig_obj[0] = args;
10605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10606 if (!SWIG_IsOK(res1)) {
10607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10608 }
10609 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10610 {
10611 PyThreadState* __tstate = wxPyBeginAllowThreads();
10612 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10613 wxPyEndAllowThreads(__tstate);
10614 if (PyErr_Occurred()) SWIG_fail;
10615 }
10616 resultobj = SWIG_From_int(static_cast< int >(result));
10617 return resultobj;
10618 fail:
10619 return NULL;
10620 }
10621
10622
10623 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10624 PyObject *resultobj = 0;
10625 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10626 wxString result;
10627 void *argp1 = 0 ;
10628 int res1 = 0 ;
10629 PyObject *swig_obj[1] ;
10630
10631 if (!args) SWIG_fail;
10632 swig_obj[0] = args;
10633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10634 if (!SWIG_IsOK(res1)) {
10635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10636 }
10637 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10638 {
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10641 wxPyEndAllowThreads(__tstate);
10642 if (PyErr_Occurred()) SWIG_fail;
10643 }
10644 {
10645 #if wxUSE_UNICODE
10646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10647 #else
10648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10649 #endif
10650 }
10651 return resultobj;
10652 fail:
10653 return NULL;
10654 }
10655
10656
10657 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10658 PyObject *resultobj = 0;
10659 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10660 wxString result;
10661 void *argp1 = 0 ;
10662 int res1 = 0 ;
10663 PyObject *swig_obj[1] ;
10664
10665 if (!args) SWIG_fail;
10666 swig_obj[0] = args;
10667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10668 if (!SWIG_IsOK(res1)) {
10669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10670 }
10671 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10672 {
10673 PyThreadState* __tstate = wxPyBeginAllowThreads();
10674 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10675 wxPyEndAllowThreads(__tstate);
10676 if (PyErr_Occurred()) SWIG_fail;
10677 }
10678 {
10679 #if wxUSE_UNICODE
10680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10681 #else
10682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10683 #endif
10684 }
10685 return resultobj;
10686 fail:
10687 return NULL;
10688 }
10689
10690
10691 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10692 PyObject *resultobj = 0;
10693 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10694 wxString result;
10695 void *argp1 = 0 ;
10696 int res1 = 0 ;
10697 PyObject *swig_obj[1] ;
10698
10699 if (!args) SWIG_fail;
10700 swig_obj[0] = args;
10701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10702 if (!SWIG_IsOK(res1)) {
10703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10704 }
10705 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10706 {
10707 PyThreadState* __tstate = wxPyBeginAllowThreads();
10708 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10709 wxPyEndAllowThreads(__tstate);
10710 if (PyErr_Occurred()) SWIG_fail;
10711 }
10712 {
10713 #if wxUSE_UNICODE
10714 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10715 #else
10716 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10717 #endif
10718 }
10719 return resultobj;
10720 fail:
10721 return NULL;
10722 }
10723
10724
10725 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10726 PyObject *resultobj = 0;
10727 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10728 wxString result;
10729 void *argp1 = 0 ;
10730 int res1 = 0 ;
10731 PyObject *swig_obj[1] ;
10732
10733 if (!args) SWIG_fail;
10734 swig_obj[0] = args;
10735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10736 if (!SWIG_IsOK(res1)) {
10737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10738 }
10739 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 {
10747 #if wxUSE_UNICODE
10748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10749 #else
10750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10751 #endif
10752 }
10753 return resultobj;
10754 fail:
10755 return NULL;
10756 }
10757
10758
10759 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10760 PyObject *resultobj = 0;
10761 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10762 wxString result;
10763 void *argp1 = 0 ;
10764 int res1 = 0 ;
10765 PyObject *swig_obj[1] ;
10766
10767 if (!args) SWIG_fail;
10768 swig_obj[0] = args;
10769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10770 if (!SWIG_IsOK(res1)) {
10771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10772 }
10773 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10774 {
10775 PyThreadState* __tstate = wxPyBeginAllowThreads();
10776 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10777 wxPyEndAllowThreads(__tstate);
10778 if (PyErr_Occurred()) SWIG_fail;
10779 }
10780 {
10781 #if wxUSE_UNICODE
10782 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10783 #else
10784 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10785 #endif
10786 }
10787 return resultobj;
10788 fail:
10789 return NULL;
10790 }
10791
10792
10793 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10794 PyObject *resultobj = 0;
10795 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10796 wxString result;
10797 void *argp1 = 0 ;
10798 int res1 = 0 ;
10799 PyObject *swig_obj[1] ;
10800
10801 if (!args) SWIG_fail;
10802 swig_obj[0] = args;
10803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10804 if (!SWIG_IsOK(res1)) {
10805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10806 }
10807 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10808 {
10809 PyThreadState* __tstate = wxPyBeginAllowThreads();
10810 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10811 wxPyEndAllowThreads(__tstate);
10812 if (PyErr_Occurred()) SWIG_fail;
10813 }
10814 {
10815 #if wxUSE_UNICODE
10816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10817 #else
10818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10819 #endif
10820 }
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = 0;
10829 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10830 int arg2 ;
10831 int arg3 ;
10832 void *argp1 = 0 ;
10833 int res1 = 0 ;
10834 int val2 ;
10835 int ecode2 = 0 ;
10836 int val3 ;
10837 int ecode3 = 0 ;
10838 PyObject * obj0 = 0 ;
10839 PyObject * obj1 = 0 ;
10840 PyObject * obj2 = 0 ;
10841 char * kwnames[] = {
10842 (char *) "self",(char *) "major",(char *) "minor", NULL
10843 };
10844
10845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10847 if (!SWIG_IsOK(res1)) {
10848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10849 }
10850 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10851 ecode2 = SWIG_AsVal_int(obj1, &val2);
10852 if (!SWIG_IsOK(ecode2)) {
10853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10854 }
10855 arg2 = static_cast< int >(val2);
10856 ecode3 = SWIG_AsVal_int(obj2, &val3);
10857 if (!SWIG_IsOK(ecode3)) {
10858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10859 }
10860 arg3 = static_cast< int >(val3);
10861 {
10862 PyThreadState* __tstate = wxPyBeginAllowThreads();
10863 (arg1)->SetOSVersion(arg2,arg3);
10864 wxPyEndAllowThreads(__tstate);
10865 if (PyErr_Occurred()) SWIG_fail;
10866 }
10867 resultobj = SWIG_Py_Void();
10868 return resultobj;
10869 fail:
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj = 0;
10876 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10877 int arg2 ;
10878 int arg3 ;
10879 void *argp1 = 0 ;
10880 int res1 = 0 ;
10881 int val2 ;
10882 int ecode2 = 0 ;
10883 int val3 ;
10884 int ecode3 = 0 ;
10885 PyObject * obj0 = 0 ;
10886 PyObject * obj1 = 0 ;
10887 PyObject * obj2 = 0 ;
10888 char * kwnames[] = {
10889 (char *) "self",(char *) "major",(char *) "minor", NULL
10890 };
10891
10892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10894 if (!SWIG_IsOK(res1)) {
10895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10896 }
10897 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10898 ecode2 = SWIG_AsVal_int(obj1, &val2);
10899 if (!SWIG_IsOK(ecode2)) {
10900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10901 }
10902 arg2 = static_cast< int >(val2);
10903 ecode3 = SWIG_AsVal_int(obj2, &val3);
10904 if (!SWIG_IsOK(ecode3)) {
10905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10906 }
10907 arg3 = static_cast< int >(val3);
10908 {
10909 PyThreadState* __tstate = wxPyBeginAllowThreads();
10910 (arg1)->SetToolkitVersion(arg2,arg3);
10911 wxPyEndAllowThreads(__tstate);
10912 if (PyErr_Occurred()) SWIG_fail;
10913 }
10914 resultobj = SWIG_Py_Void();
10915 return resultobj;
10916 fail:
10917 return NULL;
10918 }
10919
10920
10921 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10922 PyObject *resultobj = 0;
10923 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10924 wxOperatingSystemId arg2 ;
10925 void *argp1 = 0 ;
10926 int res1 = 0 ;
10927 int val2 ;
10928 int ecode2 = 0 ;
10929 PyObject * obj0 = 0 ;
10930 PyObject * obj1 = 0 ;
10931 char * kwnames[] = {
10932 (char *) "self",(char *) "n", NULL
10933 };
10934
10935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10937 if (!SWIG_IsOK(res1)) {
10938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10939 }
10940 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10941 ecode2 = SWIG_AsVal_int(obj1, &val2);
10942 if (!SWIG_IsOK(ecode2)) {
10943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10944 }
10945 arg2 = static_cast< wxOperatingSystemId >(val2);
10946 {
10947 PyThreadState* __tstate = wxPyBeginAllowThreads();
10948 (arg1)->SetOperatingSystemId(arg2);
10949 wxPyEndAllowThreads(__tstate);
10950 if (PyErr_Occurred()) SWIG_fail;
10951 }
10952 resultobj = SWIG_Py_Void();
10953 return resultobj;
10954 fail:
10955 return NULL;
10956 }
10957
10958
10959 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10960 PyObject *resultobj = 0;
10961 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10962 wxPortId arg2 ;
10963 void *argp1 = 0 ;
10964 int res1 = 0 ;
10965 int val2 ;
10966 int ecode2 = 0 ;
10967 PyObject * obj0 = 0 ;
10968 PyObject * obj1 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "self",(char *) "n", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10975 if (!SWIG_IsOK(res1)) {
10976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10977 }
10978 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10979 ecode2 = SWIG_AsVal_int(obj1, &val2);
10980 if (!SWIG_IsOK(ecode2)) {
10981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10982 }
10983 arg2 = static_cast< wxPortId >(val2);
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 (arg1)->SetPortId(arg2);
10987 wxPyEndAllowThreads(__tstate);
10988 if (PyErr_Occurred()) SWIG_fail;
10989 }
10990 resultobj = SWIG_Py_Void();
10991 return resultobj;
10992 fail:
10993 return NULL;
10994 }
10995
10996
10997 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10998 PyObject *resultobj = 0;
10999 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11000 wxArchitecture arg2 ;
11001 void *argp1 = 0 ;
11002 int res1 = 0 ;
11003 int val2 ;
11004 int ecode2 = 0 ;
11005 PyObject * obj0 = 0 ;
11006 PyObject * obj1 = 0 ;
11007 char * kwnames[] = {
11008 (char *) "self",(char *) "n", NULL
11009 };
11010
11011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
11012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11013 if (!SWIG_IsOK(res1)) {
11014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11015 }
11016 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11017 ecode2 = SWIG_AsVal_int(obj1, &val2);
11018 if (!SWIG_IsOK(ecode2)) {
11019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11020 }
11021 arg2 = static_cast< wxArchitecture >(val2);
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 (arg1)->SetArchitecture(arg2);
11025 wxPyEndAllowThreads(__tstate);
11026 if (PyErr_Occurred()) SWIG_fail;
11027 }
11028 resultobj = SWIG_Py_Void();
11029 return resultobj;
11030 fail:
11031 return NULL;
11032 }
11033
11034
11035 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11036 PyObject *resultobj = 0;
11037 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11038 wxEndianness arg2 ;
11039 void *argp1 = 0 ;
11040 int res1 = 0 ;
11041 int val2 ;
11042 int ecode2 = 0 ;
11043 PyObject * obj0 = 0 ;
11044 PyObject * obj1 = 0 ;
11045 char * kwnames[] = {
11046 (char *) "self",(char *) "n", NULL
11047 };
11048
11049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11051 if (!SWIG_IsOK(res1)) {
11052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11053 }
11054 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11055 ecode2 = SWIG_AsVal_int(obj1, &val2);
11056 if (!SWIG_IsOK(ecode2)) {
11057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11058 }
11059 arg2 = static_cast< wxEndianness >(val2);
11060 {
11061 PyThreadState* __tstate = wxPyBeginAllowThreads();
11062 (arg1)->SetEndianness(arg2);
11063 wxPyEndAllowThreads(__tstate);
11064 if (PyErr_Occurred()) SWIG_fail;
11065 }
11066 resultobj = SWIG_Py_Void();
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11074 PyObject *resultobj = 0;
11075 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11076 bool result;
11077 void *argp1 = 0 ;
11078 int res1 = 0 ;
11079 PyObject *swig_obj[1] ;
11080
11081 if (!args) SWIG_fail;
11082 swig_obj[0] = args;
11083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11084 if (!SWIG_IsOK(res1)) {
11085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11086 }
11087 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11091 wxPyEndAllowThreads(__tstate);
11092 if (PyErr_Occurred()) SWIG_fail;
11093 }
11094 {
11095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11096 }
11097 return resultobj;
11098 fail:
11099 return NULL;
11100 }
11101
11102
11103 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11104 PyObject *obj;
11105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11106 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11107 return SWIG_Py_Void();
11108 }
11109
11110 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11111 return SWIG_Python_InitShadowInstance(args);
11112 }
11113
11114 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11115 PyObject *resultobj = 0;
11116 wxWindow *arg1 = (wxWindow *) 0 ;
11117 wxDC *arg2 = 0 ;
11118 bool result;
11119 void *argp1 = 0 ;
11120 int res1 = 0 ;
11121 void *argp2 = 0 ;
11122 int res2 = 0 ;
11123 PyObject * obj0 = 0 ;
11124 PyObject * obj1 = 0 ;
11125 char * kwnames[] = {
11126 (char *) "window",(char *) "dc", NULL
11127 };
11128
11129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11131 if (!SWIG_IsOK(res1)) {
11132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11133 }
11134 arg1 = reinterpret_cast< wxWindow * >(argp1);
11135 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11136 if (!SWIG_IsOK(res2)) {
11137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11138 }
11139 if (!argp2) {
11140 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11141 }
11142 arg2 = reinterpret_cast< wxDC * >(argp2);
11143 {
11144 PyThreadState* __tstate = wxPyBeginAllowThreads();
11145 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11146 wxPyEndAllowThreads(__tstate);
11147 if (PyErr_Occurred()) SWIG_fail;
11148 }
11149 {
11150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11151 }
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11159 PyObject *resultobj = 0;
11160 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11161 void *argp1 = 0 ;
11162 int res1 = 0 ;
11163 PyObject *swig_obj[1] ;
11164
11165 if (!args) SWIG_fail;
11166 swig_obj[0] = args;
11167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11168 if (!SWIG_IsOK(res1)) {
11169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11170 }
11171 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 delete arg1;
11175
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 resultobj = SWIG_Py_Void();
11180 return resultobj;
11181 fail:
11182 return NULL;
11183 }
11184
11185
11186 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11187 PyObject *resultobj = 0;
11188 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11189 wxString result;
11190 void *argp1 = 0 ;
11191 int res1 = 0 ;
11192 PyObject *swig_obj[1] ;
11193
11194 if (!args) SWIG_fail;
11195 swig_obj[0] = args;
11196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11197 if (!SWIG_IsOK(res1)) {
11198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11199 }
11200 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11201 {
11202 PyThreadState* __tstate = wxPyBeginAllowThreads();
11203 result = (arg1)->GetTip();
11204 wxPyEndAllowThreads(__tstate);
11205 if (PyErr_Occurred()) SWIG_fail;
11206 }
11207 {
11208 #if wxUSE_UNICODE
11209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11210 #else
11211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11212 #endif
11213 }
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11221 PyObject *resultobj = 0;
11222 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11223 size_t result;
11224 void *argp1 = 0 ;
11225 int res1 = 0 ;
11226 PyObject *swig_obj[1] ;
11227
11228 if (!args) SWIG_fail;
11229 swig_obj[0] = args;
11230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11231 if (!SWIG_IsOK(res1)) {
11232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11233 }
11234 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11235 {
11236 PyThreadState* __tstate = wxPyBeginAllowThreads();
11237 result = (size_t)(arg1)->GetCurrentTip();
11238 wxPyEndAllowThreads(__tstate);
11239 if (PyErr_Occurred()) SWIG_fail;
11240 }
11241 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11249 PyObject *resultobj = 0;
11250 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11251 wxString *arg2 = 0 ;
11252 wxString result;
11253 void *argp1 = 0 ;
11254 int res1 = 0 ;
11255 bool temp2 = false ;
11256 PyObject * obj0 = 0 ;
11257 PyObject * obj1 = 0 ;
11258 char * kwnames[] = {
11259 (char *) "self",(char *) "tip", NULL
11260 };
11261
11262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11264 if (!SWIG_IsOK(res1)) {
11265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11266 }
11267 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11268 {
11269 arg2 = wxString_in_helper(obj1);
11270 if (arg2 == NULL) SWIG_fail;
11271 temp2 = true;
11272 }
11273 {
11274 PyThreadState* __tstate = wxPyBeginAllowThreads();
11275 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11276 wxPyEndAllowThreads(__tstate);
11277 if (PyErr_Occurred()) SWIG_fail;
11278 }
11279 {
11280 #if wxUSE_UNICODE
11281 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11282 #else
11283 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11284 #endif
11285 }
11286 {
11287 if (temp2)
11288 delete arg2;
11289 }
11290 return resultobj;
11291 fail:
11292 {
11293 if (temp2)
11294 delete arg2;
11295 }
11296 return NULL;
11297 }
11298
11299
11300 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11301 PyObject *obj;
11302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11303 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11304 return SWIG_Py_Void();
11305 }
11306
11307 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11308 PyObject *resultobj = 0;
11309 size_t arg1 ;
11310 wxPyTipProvider *result = 0 ;
11311 size_t val1 ;
11312 int ecode1 = 0 ;
11313 PyObject * obj0 = 0 ;
11314 char * kwnames[] = {
11315 (char *) "currentTip", NULL
11316 };
11317
11318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11319 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11320 if (!SWIG_IsOK(ecode1)) {
11321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11322 }
11323 arg1 = static_cast< size_t >(val1);
11324 {
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj = 0;
11339 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11340 PyObject *arg2 = (PyObject *) 0 ;
11341 PyObject *arg3 = (PyObject *) 0 ;
11342 void *argp1 = 0 ;
11343 int res1 = 0 ;
11344 PyObject * obj0 = 0 ;
11345 PyObject * obj1 = 0 ;
11346 PyObject * obj2 = 0 ;
11347 char * kwnames[] = {
11348 (char *) "self",(char *) "self",(char *) "_class", NULL
11349 };
11350
11351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11353 if (!SWIG_IsOK(res1)) {
11354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11355 }
11356 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11357 arg2 = obj1;
11358 arg3 = obj2;
11359 {
11360 PyThreadState* __tstate = wxPyBeginAllowThreads();
11361 (arg1)->_setCallbackInfo(arg2,arg3);
11362 wxPyEndAllowThreads(__tstate);
11363 if (PyErr_Occurred()) SWIG_fail;
11364 }
11365 resultobj = SWIG_Py_Void();
11366 return resultobj;
11367 fail:
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11373 PyObject *obj;
11374 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11375 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11376 return SWIG_Py_Void();
11377 }
11378
11379 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11380 return SWIG_Python_InitShadowInstance(args);
11381 }
11382
11383 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11384 PyObject *resultobj = 0;
11385 wxWindow *arg1 = (wxWindow *) 0 ;
11386 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11387 bool arg3 = (bool) true ;
11388 bool result;
11389 void *argp1 = 0 ;
11390 int res1 = 0 ;
11391 void *argp2 = 0 ;
11392 int res2 = 0 ;
11393 bool val3 ;
11394 int ecode3 = 0 ;
11395 PyObject * obj0 = 0 ;
11396 PyObject * obj1 = 0 ;
11397 PyObject * obj2 = 0 ;
11398 char * kwnames[] = {
11399 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11400 };
11401
11402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11404 if (!SWIG_IsOK(res1)) {
11405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11406 }
11407 arg1 = reinterpret_cast< wxWindow * >(argp1);
11408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11409 if (!SWIG_IsOK(res2)) {
11410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11411 }
11412 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11413 if (obj2) {
11414 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11415 if (!SWIG_IsOK(ecode3)) {
11416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11417 }
11418 arg3 = static_cast< bool >(val3);
11419 }
11420 {
11421 if (!wxPyCheckForApp()) SWIG_fail;
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 result = (bool)wxShowTip(arg1,arg2,arg3);
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 {
11428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11429 }
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11437 PyObject *resultobj = 0;
11438 wxString *arg1 = 0 ;
11439 size_t arg2 ;
11440 wxTipProvider *result = 0 ;
11441 bool temp1 = false ;
11442 size_t val2 ;
11443 int ecode2 = 0 ;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 char * kwnames[] = {
11447 (char *) "filename",(char *) "currentTip", NULL
11448 };
11449
11450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11451 {
11452 arg1 = wxString_in_helper(obj0);
11453 if (arg1 == NULL) SWIG_fail;
11454 temp1 = true;
11455 }
11456 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11457 if (!SWIG_IsOK(ecode2)) {
11458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11459 }
11460 arg2 = static_cast< size_t >(val2);
11461 {
11462 if (!wxPyCheckForApp()) SWIG_fail;
11463 PyThreadState* __tstate = wxPyBeginAllowThreads();
11464 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11469 {
11470 if (temp1)
11471 delete arg1;
11472 }
11473 return resultobj;
11474 fail:
11475 {
11476 if (temp1)
11477 delete arg1;
11478 }
11479 return NULL;
11480 }
11481
11482
11483 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11484 PyObject *resultobj = 0;
11485 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11486 int arg2 = (int) wxID_ANY ;
11487 wxPyTimer *result = 0 ;
11488 void *argp1 = 0 ;
11489 int res1 = 0 ;
11490 int val2 ;
11491 int ecode2 = 0 ;
11492 PyObject * obj0 = 0 ;
11493 PyObject * obj1 = 0 ;
11494 char * kwnames[] = {
11495 (char *) "owner",(char *) "id", NULL
11496 };
11497
11498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11499 if (obj0) {
11500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11501 if (!SWIG_IsOK(res1)) {
11502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11503 }
11504 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11505 }
11506 if (obj1) {
11507 ecode2 = SWIG_AsVal_int(obj1, &val2);
11508 if (!SWIG_IsOK(ecode2)) {
11509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11510 }
11511 arg2 = static_cast< int >(val2);
11512 }
11513 {
11514 if (!wxPyCheckForApp()) SWIG_fail;
11515 PyThreadState* __tstate = wxPyBeginAllowThreads();
11516 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11517 wxPyEndAllowThreads(__tstate);
11518 if (PyErr_Occurred()) SWIG_fail;
11519 }
11520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11521 return resultobj;
11522 fail:
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11528 PyObject *resultobj = 0;
11529 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11530 void *argp1 = 0 ;
11531 int res1 = 0 ;
11532 PyObject *swig_obj[1] ;
11533
11534 if (!args) SWIG_fail;
11535 swig_obj[0] = args;
11536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11537 if (!SWIG_IsOK(res1)) {
11538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11539 }
11540 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 delete arg1;
11544
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 resultobj = SWIG_Py_Void();
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj = 0;
11557 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11558 PyObject *arg2 = (PyObject *) 0 ;
11559 PyObject *arg3 = (PyObject *) 0 ;
11560 int arg4 = (int) 0 ;
11561 void *argp1 = 0 ;
11562 int res1 = 0 ;
11563 int val4 ;
11564 int ecode4 = 0 ;
11565 PyObject * obj0 = 0 ;
11566 PyObject * obj1 = 0 ;
11567 PyObject * obj2 = 0 ;
11568 PyObject * obj3 = 0 ;
11569 char * kwnames[] = {
11570 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11571 };
11572
11573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11575 if (!SWIG_IsOK(res1)) {
11576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11577 }
11578 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11579 arg2 = obj1;
11580 arg3 = obj2;
11581 if (obj3) {
11582 ecode4 = SWIG_AsVal_int(obj3, &val4);
11583 if (!SWIG_IsOK(ecode4)) {
11584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11585 }
11586 arg4 = static_cast< int >(val4);
11587 }
11588 {
11589 PyThreadState* __tstate = wxPyBeginAllowThreads();
11590 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11591 wxPyEndAllowThreads(__tstate);
11592 if (PyErr_Occurred()) SWIG_fail;
11593 }
11594 resultobj = SWIG_Py_Void();
11595 return resultobj;
11596 fail:
11597 return NULL;
11598 }
11599
11600
11601 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11602 PyObject *resultobj = 0;
11603 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11604 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11605 int arg3 = (int) wxID_ANY ;
11606 void *argp1 = 0 ;
11607 int res1 = 0 ;
11608 void *argp2 = 0 ;
11609 int res2 = 0 ;
11610 int val3 ;
11611 int ecode3 = 0 ;
11612 PyObject * obj0 = 0 ;
11613 PyObject * obj1 = 0 ;
11614 PyObject * obj2 = 0 ;
11615 char * kwnames[] = {
11616 (char *) "self",(char *) "owner",(char *) "id", NULL
11617 };
11618
11619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11621 if (!SWIG_IsOK(res1)) {
11622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11623 }
11624 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11626 if (!SWIG_IsOK(res2)) {
11627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11628 }
11629 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11630 if (obj2) {
11631 ecode3 = SWIG_AsVal_int(obj2, &val3);
11632 if (!SWIG_IsOK(ecode3)) {
11633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11634 }
11635 arg3 = static_cast< int >(val3);
11636 }
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 (arg1)->SetOwner(arg2,arg3);
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 resultobj = SWIG_Py_Void();
11644 return resultobj;
11645 fail:
11646 return NULL;
11647 }
11648
11649
11650 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11651 PyObject *resultobj = 0;
11652 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11653 wxEvtHandler *result = 0 ;
11654 void *argp1 = 0 ;
11655 int res1 = 0 ;
11656 PyObject *swig_obj[1] ;
11657
11658 if (!args) SWIG_fail;
11659 swig_obj[0] = args;
11660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11661 if (!SWIG_IsOK(res1)) {
11662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11663 }
11664 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (wxEvtHandler *)(arg1)->GetOwner();
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 resultobj = wxPyMake_wxObject(result, 0);
11673 }
11674 return resultobj;
11675 fail:
11676 return NULL;
11677 }
11678
11679
11680 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11681 PyObject *resultobj = 0;
11682 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11683 int arg2 = (int) -1 ;
11684 bool arg3 = (bool) false ;
11685 bool result;
11686 void *argp1 = 0 ;
11687 int res1 = 0 ;
11688 int val2 ;
11689 int ecode2 = 0 ;
11690 bool val3 ;
11691 int ecode3 = 0 ;
11692 PyObject * obj0 = 0 ;
11693 PyObject * obj1 = 0 ;
11694 PyObject * obj2 = 0 ;
11695 char * kwnames[] = {
11696 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11697 };
11698
11699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11701 if (!SWIG_IsOK(res1)) {
11702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11703 }
11704 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11705 if (obj1) {
11706 ecode2 = SWIG_AsVal_int(obj1, &val2);
11707 if (!SWIG_IsOK(ecode2)) {
11708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11709 }
11710 arg2 = static_cast< int >(val2);
11711 }
11712 if (obj2) {
11713 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11714 if (!SWIG_IsOK(ecode3)) {
11715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11716 }
11717 arg3 = static_cast< bool >(val3);
11718 }
11719 {
11720 PyThreadState* __tstate = wxPyBeginAllowThreads();
11721 result = (bool)(arg1)->Start(arg2,arg3);
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 {
11726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11727 }
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 PyObject *resultobj = 0;
11736 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 PyObject *swig_obj[1] ;
11740
11741 if (!args) SWIG_fail;
11742 swig_obj[0] = args;
11743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11746 }
11747 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 (arg1)->Stop();
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 resultobj = SWIG_Py_Void();
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11762 PyObject *resultobj = 0;
11763 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11764 void *argp1 = 0 ;
11765 int res1 = 0 ;
11766 PyObject *swig_obj[1] ;
11767
11768 if (!args) SWIG_fail;
11769 swig_obj[0] = args;
11770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11771 if (!SWIG_IsOK(res1)) {
11772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11773 }
11774 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 (arg1)->Notify();
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 resultobj = SWIG_Py_Void();
11782 return resultobj;
11783 fail:
11784 return NULL;
11785 }
11786
11787
11788 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11789 PyObject *resultobj = 0;
11790 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11791 bool result;
11792 void *argp1 = 0 ;
11793 int res1 = 0 ;
11794 PyObject *swig_obj[1] ;
11795
11796 if (!args) SWIG_fail;
11797 swig_obj[0] = args;
11798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11799 if (!SWIG_IsOK(res1)) {
11800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11801 }
11802 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11803 {
11804 PyThreadState* __tstate = wxPyBeginAllowThreads();
11805 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 {
11810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11811 }
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11819 PyObject *resultobj = 0;
11820 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11821 int result;
11822 void *argp1 = 0 ;
11823 int res1 = 0 ;
11824 PyObject *swig_obj[1] ;
11825
11826 if (!args) SWIG_fail;
11827 swig_obj[0] = args;
11828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11829 if (!SWIG_IsOK(res1)) {
11830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11831 }
11832 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11833 {
11834 PyThreadState* __tstate = wxPyBeginAllowThreads();
11835 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11836 wxPyEndAllowThreads(__tstate);
11837 if (PyErr_Occurred()) SWIG_fail;
11838 }
11839 resultobj = SWIG_From_int(static_cast< int >(result));
11840 return resultobj;
11841 fail:
11842 return NULL;
11843 }
11844
11845
11846 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11847 PyObject *resultobj = 0;
11848 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11849 int result;
11850 void *argp1 = 0 ;
11851 int res1 = 0 ;
11852 PyObject *swig_obj[1] ;
11853
11854 if (!args) SWIG_fail;
11855 swig_obj[0] = args;
11856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11857 if (!SWIG_IsOK(res1)) {
11858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11859 }
11860 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11861 {
11862 PyThreadState* __tstate = wxPyBeginAllowThreads();
11863 result = (int)((wxPyTimer const *)arg1)->GetId();
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 resultobj = SWIG_From_int(static_cast< int >(result));
11868 return resultobj;
11869 fail:
11870 return NULL;
11871 }
11872
11873
11874 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11875 PyObject *resultobj = 0;
11876 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11877 bool result;
11878 void *argp1 = 0 ;
11879 int res1 = 0 ;
11880 PyObject *swig_obj[1] ;
11881
11882 if (!args) SWIG_fail;
11883 swig_obj[0] = args;
11884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11885 if (!SWIG_IsOK(res1)) {
11886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11887 }
11888 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 {
11896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11897 }
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11905 PyObject *obj;
11906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11907 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11908 return SWIG_Py_Void();
11909 }
11910
11911 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11912 return SWIG_Python_InitShadowInstance(args);
11913 }
11914
11915 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11916 PyObject *resultobj = 0;
11917 int arg1 = (int) 0 ;
11918 int arg2 = (int) 0 ;
11919 wxTimerEvent *result = 0 ;
11920 int val1 ;
11921 int ecode1 = 0 ;
11922 int val2 ;
11923 int ecode2 = 0 ;
11924 PyObject * obj0 = 0 ;
11925 PyObject * obj1 = 0 ;
11926 char * kwnames[] = {
11927 (char *) "timerid",(char *) "interval", NULL
11928 };
11929
11930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11931 if (obj0) {
11932 ecode1 = SWIG_AsVal_int(obj0, &val1);
11933 if (!SWIG_IsOK(ecode1)) {
11934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11935 }
11936 arg1 = static_cast< int >(val1);
11937 }
11938 if (obj1) {
11939 ecode2 = SWIG_AsVal_int(obj1, &val2);
11940 if (!SWIG_IsOK(ecode2)) {
11941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11942 }
11943 arg2 = static_cast< int >(val2);
11944 }
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11952 return resultobj;
11953 fail:
11954 return NULL;
11955 }
11956
11957
11958 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11959 PyObject *resultobj = 0;
11960 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11961 int result;
11962 void *argp1 = 0 ;
11963 int res1 = 0 ;
11964 PyObject *swig_obj[1] ;
11965
11966 if (!args) SWIG_fail;
11967 swig_obj[0] = args;
11968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11969 if (!SWIG_IsOK(res1)) {
11970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11971 }
11972 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 resultobj = SWIG_From_int(static_cast< int >(result));
11980 return resultobj;
11981 fail:
11982 return NULL;
11983 }
11984
11985
11986 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11987 PyObject *obj;
11988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11989 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11990 return SWIG_Py_Void();
11991 }
11992
11993 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11994 return SWIG_Python_InitShadowInstance(args);
11995 }
11996
11997 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11998 PyObject *resultobj = 0;
11999 wxTimer *arg1 = 0 ;
12000 wxTimerRunner *result = 0 ;
12001 void *argp1 = 0 ;
12002 int res1 = 0 ;
12003
12004 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
12005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12006 if (!SWIG_IsOK(res1)) {
12007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12008 }
12009 if (!argp1) {
12010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12011 }
12012 arg1 = reinterpret_cast< wxTimer * >(argp1);
12013 {
12014 if (!wxPyCheckForApp()) SWIG_fail;
12015 PyThreadState* __tstate = wxPyBeginAllowThreads();
12016 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12017 wxPyEndAllowThreads(__tstate);
12018 if (PyErr_Occurred()) SWIG_fail;
12019 }
12020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12028 PyObject *resultobj = 0;
12029 wxTimer *arg1 = 0 ;
12030 int arg2 ;
12031 bool arg3 = (bool) false ;
12032 wxTimerRunner *result = 0 ;
12033 void *argp1 = 0 ;
12034 int res1 = 0 ;
12035 int val2 ;
12036 int ecode2 = 0 ;
12037 bool val3 ;
12038 int ecode3 = 0 ;
12039
12040 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12042 if (!SWIG_IsOK(res1)) {
12043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12044 }
12045 if (!argp1) {
12046 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12047 }
12048 arg1 = reinterpret_cast< wxTimer * >(argp1);
12049 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12050 if (!SWIG_IsOK(ecode2)) {
12051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12052 }
12053 arg2 = static_cast< int >(val2);
12054 if (swig_obj[2]) {
12055 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12056 if (!SWIG_IsOK(ecode3)) {
12057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12058 }
12059 arg3 = static_cast< bool >(val3);
12060 }
12061 {
12062 if (!wxPyCheckForApp()) SWIG_fail;
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12065 wxPyEndAllowThreads(__tstate);
12066 if (PyErr_Occurred()) SWIG_fail;
12067 }
12068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12069 return resultobj;
12070 fail:
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12076 int argc;
12077 PyObject *argv[4];
12078
12079 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12080 --argc;
12081 if (argc == 1) {
12082 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12083 }
12084 if ((argc >= 2) && (argc <= 3)) {
12085 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12086 }
12087
12088 fail:
12089 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12090 return NULL;
12091 }
12092
12093
12094 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 PyObject *resultobj = 0;
12096 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12097 void *argp1 = 0 ;
12098 int res1 = 0 ;
12099 PyObject *swig_obj[1] ;
12100
12101 if (!args) SWIG_fail;
12102 swig_obj[0] = args;
12103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12104 if (!SWIG_IsOK(res1)) {
12105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12106 }
12107 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 delete arg1;
12111
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 resultobj = SWIG_Py_Void();
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12123 PyObject *resultobj = 0;
12124 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12125 int arg2 ;
12126 bool arg3 = (bool) false ;
12127 void *argp1 = 0 ;
12128 int res1 = 0 ;
12129 int val2 ;
12130 int ecode2 = 0 ;
12131 bool val3 ;
12132 int ecode3 = 0 ;
12133 PyObject * obj0 = 0 ;
12134 PyObject * obj1 = 0 ;
12135 PyObject * obj2 = 0 ;
12136 char * kwnames[] = {
12137 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12138 };
12139
12140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12142 if (!SWIG_IsOK(res1)) {
12143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12144 }
12145 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12146 ecode2 = SWIG_AsVal_int(obj1, &val2);
12147 if (!SWIG_IsOK(ecode2)) {
12148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12149 }
12150 arg2 = static_cast< int >(val2);
12151 if (obj2) {
12152 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12153 if (!SWIG_IsOK(ecode3)) {
12154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12155 }
12156 arg3 = static_cast< bool >(val3);
12157 }
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 (arg1)->Start(arg2,arg3);
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_Py_Void();
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *obj;
12173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12174 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12175 return SWIG_Py_Void();
12176 }
12177
12178 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12179 return SWIG_Python_InitShadowInstance(args);
12180 }
12181
12182 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12183 PyObject *resultobj = 0;
12184 wxLog *result = 0 ;
12185
12186 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (wxLog *)new wxLog();
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12201 PyObject *resultobj = 0;
12202 wxLog *arg1 = (wxLog *) 0 ;
12203 void *argp1 = 0 ;
12204 int res1 = 0 ;
12205 PyObject *swig_obj[1] ;
12206
12207 if (!args) SWIG_fail;
12208 swig_obj[0] = args;
12209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12210 if (!SWIG_IsOK(res1)) {
12211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12212 }
12213 arg1 = reinterpret_cast< wxLog * >(argp1);
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 delete arg1;
12217
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 resultobj = SWIG_Py_Void();
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12229 PyObject *resultobj = 0;
12230 bool result;
12231
12232 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12233 {
12234 PyThreadState* __tstate = wxPyBeginAllowThreads();
12235 result = (bool)wxLog::IsEnabled();
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 {
12240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12241 }
12242 return resultobj;
12243 fail:
12244 return NULL;
12245 }
12246
12247
12248 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12249 PyObject *resultobj = 0;
12250 bool arg1 = (bool) true ;
12251 bool result;
12252 bool val1 ;
12253 int ecode1 = 0 ;
12254 PyObject * obj0 = 0 ;
12255 char * kwnames[] = {
12256 (char *) "doIt", NULL
12257 };
12258
12259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12260 if (obj0) {
12261 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12262 if (!SWIG_IsOK(ecode1)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12264 }
12265 arg1 = static_cast< bool >(val1);
12266 }
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (bool)wxLog::EnableLogging(arg1);
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 {
12274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12275 }
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12283 PyObject *resultobj = 0;
12284 wxLogLevel arg1 ;
12285 wxChar *arg2 = (wxChar *) 0 ;
12286 time_t arg3 ;
12287 unsigned long val1 ;
12288 int ecode1 = 0 ;
12289 void *argp2 = 0 ;
12290 int res2 = 0 ;
12291 unsigned int val3 ;
12292 int ecode3 = 0 ;
12293 PyObject * obj0 = 0 ;
12294 PyObject * obj1 = 0 ;
12295 PyObject * obj2 = 0 ;
12296 char * kwnames[] = {
12297 (char *) "level",(char *) "szString",(char *) "t", NULL
12298 };
12299
12300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12301 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12302 if (!SWIG_IsOK(ecode1)) {
12303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12304 }
12305 arg1 = static_cast< wxLogLevel >(val1);
12306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12307 if (!SWIG_IsOK(res2)) {
12308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12309 }
12310 arg2 = reinterpret_cast< wxChar * >(argp2);
12311 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12312 if (!SWIG_IsOK(ecode3)) {
12313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12314 }
12315 arg3 = static_cast< time_t >(val3);
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 resultobj = SWIG_Py_Void();
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12330 PyObject *resultobj = 0;
12331 wxLog *arg1 = (wxLog *) 0 ;
12332 void *argp1 = 0 ;
12333 int res1 = 0 ;
12334 PyObject *swig_obj[1] ;
12335
12336 if (!args) SWIG_fail;
12337 swig_obj[0] = args;
12338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12339 if (!SWIG_IsOK(res1)) {
12340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12341 }
12342 arg1 = reinterpret_cast< wxLog * >(argp1);
12343 {
12344 PyThreadState* __tstate = wxPyBeginAllowThreads();
12345 (arg1)->Flush();
12346 wxPyEndAllowThreads(__tstate);
12347 if (PyErr_Occurred()) SWIG_fail;
12348 }
12349 resultobj = SWIG_Py_Void();
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357 PyObject *resultobj = 0;
12358
12359 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 wxLog::FlushActive();
12363 wxPyEndAllowThreads(__tstate);
12364 if (PyErr_Occurred()) SWIG_fail;
12365 }
12366 resultobj = SWIG_Py_Void();
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12374 PyObject *resultobj = 0;
12375 wxLog *result = 0 ;
12376
12377 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 result = (wxLog *)wxLog::GetActiveTarget();
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12385 return resultobj;
12386 fail:
12387 return NULL;
12388 }
12389
12390
12391 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12392 PyObject *resultobj = 0;
12393 wxLog *arg1 = (wxLog *) 0 ;
12394 wxLog *result = 0 ;
12395 int res1 = 0 ;
12396 PyObject * obj0 = 0 ;
12397 char * kwnames[] = {
12398 (char *) "pLogger", NULL
12399 };
12400
12401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12402 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12403 if (!SWIG_IsOK(res1)) {
12404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12405 }
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12420 PyObject *resultobj = 0;
12421
12422 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 wxLog::Suspend();
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 resultobj = SWIG_Py_Void();
12430 return resultobj;
12431 fail:
12432 return NULL;
12433 }
12434
12435
12436 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12437 PyObject *resultobj = 0;
12438
12439 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12440 {
12441 PyThreadState* __tstate = wxPyBeginAllowThreads();
12442 wxLog::Resume();
12443 wxPyEndAllowThreads(__tstate);
12444 if (PyErr_Occurred()) SWIG_fail;
12445 }
12446 resultobj = SWIG_Py_Void();
12447 return resultobj;
12448 fail:
12449 return NULL;
12450 }
12451
12452
12453 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12454 PyObject *resultobj = 0;
12455 bool arg1 = (bool) true ;
12456 bool val1 ;
12457 int ecode1 = 0 ;
12458 PyObject * obj0 = 0 ;
12459 char * kwnames[] = {
12460 (char *) "bVerbose", NULL
12461 };
12462
12463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12464 if (obj0) {
12465 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12466 if (!SWIG_IsOK(ecode1)) {
12467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12468 }
12469 arg1 = static_cast< bool >(val1);
12470 }
12471 {
12472 PyThreadState* __tstate = wxPyBeginAllowThreads();
12473 wxLog::SetVerbose(arg1);
12474 wxPyEndAllowThreads(__tstate);
12475 if (PyErr_Occurred()) SWIG_fail;
12476 }
12477 resultobj = SWIG_Py_Void();
12478 return resultobj;
12479 fail:
12480 return NULL;
12481 }
12482
12483
12484 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12485 PyObject *resultobj = 0;
12486 wxLogLevel arg1 ;
12487 unsigned long val1 ;
12488 int ecode1 = 0 ;
12489 PyObject * obj0 = 0 ;
12490 char * kwnames[] = {
12491 (char *) "logLevel", NULL
12492 };
12493
12494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12495 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12496 if (!SWIG_IsOK(ecode1)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12498 }
12499 arg1 = static_cast< wxLogLevel >(val1);
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 wxLog::SetLogLevel(arg1);
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 resultobj = SWIG_Py_Void();
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12514 PyObject *resultobj = 0;
12515
12516 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12517 {
12518 PyThreadState* __tstate = wxPyBeginAllowThreads();
12519 wxLog::DontCreateOnDemand();
12520 wxPyEndAllowThreads(__tstate);
12521 if (PyErr_Occurred()) SWIG_fail;
12522 }
12523 resultobj = SWIG_Py_Void();
12524 return resultobj;
12525 fail:
12526 return NULL;
12527 }
12528
12529
12530 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12531 PyObject *resultobj = 0;
12532 bool arg1 = (bool) true ;
12533 bool val1 ;
12534 int ecode1 = 0 ;
12535 PyObject * obj0 = 0 ;
12536 char * kwnames[] = {
12537 (char *) "bRepetCounting", NULL
12538 };
12539
12540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12541 if (obj0) {
12542 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12543 if (!SWIG_IsOK(ecode1)) {
12544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12545 }
12546 arg1 = static_cast< bool >(val1);
12547 }
12548 {
12549 PyThreadState* __tstate = wxPyBeginAllowThreads();
12550 wxLog::SetRepetitionCounting(arg1);
12551 wxPyEndAllowThreads(__tstate);
12552 if (PyErr_Occurred()) SWIG_fail;
12553 }
12554 resultobj = SWIG_Py_Void();
12555 return resultobj;
12556 fail:
12557 return NULL;
12558 }
12559
12560
12561 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12562 PyObject *resultobj = 0;
12563 bool result;
12564
12565 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12566 {
12567 PyThreadState* __tstate = wxPyBeginAllowThreads();
12568 result = (bool)wxLog::GetRepetitionCounting();
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 {
12573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12574 }
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj = 0;
12583 wxTraceMask arg1 ;
12584 unsigned long val1 ;
12585 int ecode1 = 0 ;
12586 PyObject * obj0 = 0 ;
12587 char * kwnames[] = {
12588 (char *) "ulMask", NULL
12589 };
12590
12591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12592 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12593 if (!SWIG_IsOK(ecode1)) {
12594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12595 }
12596 arg1 = static_cast< wxTraceMask >(val1);
12597 {
12598 PyThreadState* __tstate = wxPyBeginAllowThreads();
12599 wxLog::SetTraceMask(arg1);
12600 wxPyEndAllowThreads(__tstate);
12601 if (PyErr_Occurred()) SWIG_fail;
12602 }
12603 resultobj = SWIG_Py_Void();
12604 return resultobj;
12605 fail:
12606 return NULL;
12607 }
12608
12609
12610 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12611 PyObject *resultobj = 0;
12612 wxString *arg1 = 0 ;
12613 bool temp1 = false ;
12614 PyObject * obj0 = 0 ;
12615 char * kwnames[] = {
12616 (char *) "str", NULL
12617 };
12618
12619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12620 {
12621 arg1 = wxString_in_helper(obj0);
12622 if (arg1 == NULL) SWIG_fail;
12623 temp1 = true;
12624 }
12625 {
12626 PyThreadState* __tstate = wxPyBeginAllowThreads();
12627 wxLog::AddTraceMask((wxString const &)*arg1);
12628 wxPyEndAllowThreads(__tstate);
12629 if (PyErr_Occurred()) SWIG_fail;
12630 }
12631 resultobj = SWIG_Py_Void();
12632 {
12633 if (temp1)
12634 delete arg1;
12635 }
12636 return resultobj;
12637 fail:
12638 {
12639 if (temp1)
12640 delete arg1;
12641 }
12642 return NULL;
12643 }
12644
12645
12646 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12647 PyObject *resultobj = 0;
12648 wxString *arg1 = 0 ;
12649 bool temp1 = false ;
12650 PyObject * obj0 = 0 ;
12651 char * kwnames[] = {
12652 (char *) "str", NULL
12653 };
12654
12655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12656 {
12657 arg1 = wxString_in_helper(obj0);
12658 if (arg1 == NULL) SWIG_fail;
12659 temp1 = true;
12660 }
12661 {
12662 PyThreadState* __tstate = wxPyBeginAllowThreads();
12663 wxLog::RemoveTraceMask((wxString const &)*arg1);
12664 wxPyEndAllowThreads(__tstate);
12665 if (PyErr_Occurred()) SWIG_fail;
12666 }
12667 resultobj = SWIG_Py_Void();
12668 {
12669 if (temp1)
12670 delete arg1;
12671 }
12672 return resultobj;
12673 fail:
12674 {
12675 if (temp1)
12676 delete arg1;
12677 }
12678 return NULL;
12679 }
12680
12681
12682 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12683 PyObject *resultobj = 0;
12684
12685 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12686 {
12687 PyThreadState* __tstate = wxPyBeginAllowThreads();
12688 wxLog::ClearTraceMasks();
12689 wxPyEndAllowThreads(__tstate);
12690 if (PyErr_Occurred()) SWIG_fail;
12691 }
12692 resultobj = SWIG_Py_Void();
12693 return resultobj;
12694 fail:
12695 return NULL;
12696 }
12697
12698
12699 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12700 PyObject *resultobj = 0;
12701 wxArrayString *result = 0 ;
12702
12703 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 {
12707 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12708 result = (wxArrayString *) &_result_ref;
12709 }
12710 wxPyEndAllowThreads(__tstate);
12711 if (PyErr_Occurred()) SWIG_fail;
12712 }
12713 {
12714 resultobj = wxArrayString2PyList_helper(*result);
12715 }
12716 return resultobj;
12717 fail:
12718 return NULL;
12719 }
12720
12721
12722 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12723 PyObject *resultobj = 0;
12724 wxChar *arg1 = (wxChar *) 0 ;
12725 void *argp1 = 0 ;
12726 int res1 = 0 ;
12727 PyObject * obj0 = 0 ;
12728 char * kwnames[] = {
12729 (char *) "ts", NULL
12730 };
12731
12732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12734 if (!SWIG_IsOK(res1)) {
12735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12736 }
12737 arg1 = reinterpret_cast< wxChar * >(argp1);
12738 {
12739 PyThreadState* __tstate = wxPyBeginAllowThreads();
12740 wxLog::SetTimestamp((wxChar const *)arg1);
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 resultobj = SWIG_Py_Void();
12745 return resultobj;
12746 fail:
12747 return NULL;
12748 }
12749
12750
12751 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12752 PyObject *resultobj = 0;
12753 bool result;
12754
12755 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12756 {
12757 PyThreadState* __tstate = wxPyBeginAllowThreads();
12758 result = (bool)wxLog::GetVerbose();
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 {
12763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12764 }
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12772 PyObject *resultobj = 0;
12773 wxTraceMask result;
12774
12775 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12776 {
12777 PyThreadState* __tstate = wxPyBeginAllowThreads();
12778 result = (wxTraceMask)wxLog::GetTraceMask();
12779 wxPyEndAllowThreads(__tstate);
12780 if (PyErr_Occurred()) SWIG_fail;
12781 }
12782 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12790 PyObject *resultobj = 0;
12791 wxChar *arg1 = (wxChar *) 0 ;
12792 bool result;
12793 void *argp1 = 0 ;
12794 int res1 = 0 ;
12795 PyObject * obj0 = 0 ;
12796 char * kwnames[] = {
12797 (char *) "mask", NULL
12798 };
12799
12800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12802 if (!SWIG_IsOK(res1)) {
12803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12804 }
12805 arg1 = reinterpret_cast< wxChar * >(argp1);
12806 {
12807 PyThreadState* __tstate = wxPyBeginAllowThreads();
12808 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 {
12813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12814 }
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12822 PyObject *resultobj = 0;
12823 wxLogLevel result;
12824
12825 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12826 {
12827 PyThreadState* __tstate = wxPyBeginAllowThreads();
12828 result = (wxLogLevel)wxLog::GetLogLevel();
12829 wxPyEndAllowThreads(__tstate);
12830 if (PyErr_Occurred()) SWIG_fail;
12831 }
12832 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12833 return resultobj;
12834 fail:
12835 return NULL;
12836 }
12837
12838
12839 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12840 PyObject *resultobj = 0;
12841 wxChar *result = 0 ;
12842
12843 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = (wxChar *)wxLog::GetTimestamp();
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12851 return resultobj;
12852 fail:
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12858 PyObject *resultobj = 0;
12859 wxString result;
12860
12861 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 result = wxLog_TimeStamp();
12865 wxPyEndAllowThreads(__tstate);
12866 if (PyErr_Occurred()) SWIG_fail;
12867 }
12868 {
12869 #if wxUSE_UNICODE
12870 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12871 #else
12872 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12873 #endif
12874 }
12875 return resultobj;
12876 fail:
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 PyObject *resultobj = 0;
12883 wxLog *arg1 = (wxLog *) 0 ;
12884 void *argp1 = 0 ;
12885 int res1 = 0 ;
12886 PyObject *swig_obj[1] ;
12887
12888 if (!args) SWIG_fail;
12889 swig_obj[0] = args;
12890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12891 if (!SWIG_IsOK(res1)) {
12892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12893 }
12894 arg1 = reinterpret_cast< wxLog * >(argp1);
12895 {
12896 PyThreadState* __tstate = wxPyBeginAllowThreads();
12897 wxLog_Destroy(arg1);
12898 wxPyEndAllowThreads(__tstate);
12899 if (PyErr_Occurred()) SWIG_fail;
12900 }
12901 resultobj = SWIG_Py_Void();
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12909 PyObject *obj;
12910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12911 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12912 return SWIG_Py_Void();
12913 }
12914
12915 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12916 return SWIG_Python_InitShadowInstance(args);
12917 }
12918
12919 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12920 PyObject *resultobj = 0;
12921 wxLogStderr *result = 0 ;
12922
12923 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 result = (wxLogStderr *)new wxLogStderr();
12927 wxPyEndAllowThreads(__tstate);
12928 if (PyErr_Occurred()) SWIG_fail;
12929 }
12930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *obj;
12939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12940 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12941 return SWIG_Py_Void();
12942 }
12943
12944 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12945 return SWIG_Python_InitShadowInstance(args);
12946 }
12947
12948 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12949 PyObject *resultobj = 0;
12950 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12951 wxLogTextCtrl *result = 0 ;
12952 void *argp1 = 0 ;
12953 int res1 = 0 ;
12954 PyObject * obj0 = 0 ;
12955 char * kwnames[] = {
12956 (char *) "pTextCtrl", NULL
12957 };
12958
12959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12961 if (!SWIG_IsOK(res1)) {
12962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12963 }
12964 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12965 {
12966 PyThreadState* __tstate = wxPyBeginAllowThreads();
12967 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12968 wxPyEndAllowThreads(__tstate);
12969 if (PyErr_Occurred()) SWIG_fail;
12970 }
12971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12979 PyObject *obj;
12980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12981 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12982 return SWIG_Py_Void();
12983 }
12984
12985 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12986 return SWIG_Python_InitShadowInstance(args);
12987 }
12988
12989 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12990 PyObject *resultobj = 0;
12991 wxLogGui *result = 0 ;
12992
12993 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12994 {
12995 PyThreadState* __tstate = wxPyBeginAllowThreads();
12996 result = (wxLogGui *)new wxLogGui();
12997 wxPyEndAllowThreads(__tstate);
12998 if (PyErr_Occurred()) SWIG_fail;
12999 }
13000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
13001 return resultobj;
13002 fail:
13003 return NULL;
13004 }
13005
13006
13007 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 PyObject *obj;
13009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13010 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
13011 return SWIG_Py_Void();
13012 }
13013
13014 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 return SWIG_Python_InitShadowInstance(args);
13016 }
13017
13018 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13019 PyObject *resultobj = 0;
13020 wxFrame *arg1 = (wxFrame *) 0 ;
13021 wxString *arg2 = 0 ;
13022 bool arg3 = (bool) true ;
13023 bool arg4 = (bool) true ;
13024 wxLogWindow *result = 0 ;
13025 void *argp1 = 0 ;
13026 int res1 = 0 ;
13027 bool temp2 = false ;
13028 bool val3 ;
13029 int ecode3 = 0 ;
13030 bool val4 ;
13031 int ecode4 = 0 ;
13032 PyObject * obj0 = 0 ;
13033 PyObject * obj1 = 0 ;
13034 PyObject * obj2 = 0 ;
13035 PyObject * obj3 = 0 ;
13036 char * kwnames[] = {
13037 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13038 };
13039
13040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13042 if (!SWIG_IsOK(res1)) {
13043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13044 }
13045 arg1 = reinterpret_cast< wxFrame * >(argp1);
13046 {
13047 arg2 = wxString_in_helper(obj1);
13048 if (arg2 == NULL) SWIG_fail;
13049 temp2 = true;
13050 }
13051 if (obj2) {
13052 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13053 if (!SWIG_IsOK(ecode3)) {
13054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13055 }
13056 arg3 = static_cast< bool >(val3);
13057 }
13058 if (obj3) {
13059 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13060 if (!SWIG_IsOK(ecode4)) {
13061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13062 }
13063 arg4 = static_cast< bool >(val4);
13064 }
13065 {
13066 PyThreadState* __tstate = wxPyBeginAllowThreads();
13067 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13068 wxPyEndAllowThreads(__tstate);
13069 if (PyErr_Occurred()) SWIG_fail;
13070 }
13071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13072 {
13073 if (temp2)
13074 delete arg2;
13075 }
13076 return resultobj;
13077 fail:
13078 {
13079 if (temp2)
13080 delete arg2;
13081 }
13082 return NULL;
13083 }
13084
13085
13086 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13087 PyObject *resultobj = 0;
13088 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13089 bool arg2 = (bool) true ;
13090 void *argp1 = 0 ;
13091 int res1 = 0 ;
13092 bool val2 ;
13093 int ecode2 = 0 ;
13094 PyObject * obj0 = 0 ;
13095 PyObject * obj1 = 0 ;
13096 char * kwnames[] = {
13097 (char *) "self",(char *) "bShow", NULL
13098 };
13099
13100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13102 if (!SWIG_IsOK(res1)) {
13103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13104 }
13105 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13106 if (obj1) {
13107 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13108 if (!SWIG_IsOK(ecode2)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13110 }
13111 arg2 = static_cast< bool >(val2);
13112 }
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 (arg1)->Show(arg2);
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 resultobj = SWIG_Py_Void();
13120 return resultobj;
13121 fail:
13122 return NULL;
13123 }
13124
13125
13126 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13127 PyObject *resultobj = 0;
13128 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13129 wxFrame *result = 0 ;
13130 void *argp1 = 0 ;
13131 int res1 = 0 ;
13132 PyObject *swig_obj[1] ;
13133
13134 if (!args) SWIG_fail;
13135 swig_obj[0] = args;
13136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13137 if (!SWIG_IsOK(res1)) {
13138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13139 }
13140 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13144 wxPyEndAllowThreads(__tstate);
13145 if (PyErr_Occurred()) SWIG_fail;
13146 }
13147 {
13148 resultobj = wxPyMake_wxObject(result, (bool)0);
13149 }
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13157 PyObject *resultobj = 0;
13158 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13159 wxLog *result = 0 ;
13160 void *argp1 = 0 ;
13161 int res1 = 0 ;
13162 PyObject *swig_obj[1] ;
13163
13164 if (!args) SWIG_fail;
13165 swig_obj[0] = args;
13166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13167 if (!SWIG_IsOK(res1)) {
13168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13169 }
13170 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13178 return resultobj;
13179 fail:
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13185 PyObject *resultobj = 0;
13186 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13187 bool result;
13188 void *argp1 = 0 ;
13189 int res1 = 0 ;
13190 PyObject *swig_obj[1] ;
13191
13192 if (!args) SWIG_fail;
13193 swig_obj[0] = args;
13194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13195 if (!SWIG_IsOK(res1)) {
13196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13197 }
13198 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13199 {
13200 PyThreadState* __tstate = wxPyBeginAllowThreads();
13201 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 {
13206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13207 }
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj = 0;
13216 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13217 bool arg2 ;
13218 void *argp1 = 0 ;
13219 int res1 = 0 ;
13220 bool val2 ;
13221 int ecode2 = 0 ;
13222 PyObject * obj0 = 0 ;
13223 PyObject * obj1 = 0 ;
13224 char * kwnames[] = {
13225 (char *) "self",(char *) "bDoPass", NULL
13226 };
13227
13228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13230 if (!SWIG_IsOK(res1)) {
13231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13232 }
13233 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13235 if (!SWIG_IsOK(ecode2)) {
13236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13237 }
13238 arg2 = static_cast< bool >(val2);
13239 {
13240 PyThreadState* __tstate = wxPyBeginAllowThreads();
13241 (arg1)->PassMessages(arg2);
13242 wxPyEndAllowThreads(__tstate);
13243 if (PyErr_Occurred()) SWIG_fail;
13244 }
13245 resultobj = SWIG_Py_Void();
13246 return resultobj;
13247 fail:
13248 return NULL;
13249 }
13250
13251
13252 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13253 PyObject *obj;
13254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13255 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13256 return SWIG_Py_Void();
13257 }
13258
13259 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13260 return SWIG_Python_InitShadowInstance(args);
13261 }
13262
13263 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13264 PyObject *resultobj = 0;
13265 wxLog *arg1 = (wxLog *) 0 ;
13266 wxLogChain *result = 0 ;
13267 void *argp1 = 0 ;
13268 int res1 = 0 ;
13269 PyObject * obj0 = 0 ;
13270 char * kwnames[] = {
13271 (char *) "logger", NULL
13272 };
13273
13274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13276 if (!SWIG_IsOK(res1)) {
13277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13278 }
13279 arg1 = reinterpret_cast< wxLog * >(argp1);
13280 {
13281 PyThreadState* __tstate = wxPyBeginAllowThreads();
13282 result = (wxLogChain *)new wxLogChain(arg1);
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13287 return resultobj;
13288 fail:
13289 return NULL;
13290 }
13291
13292
13293 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13294 PyObject *resultobj = 0;
13295 wxLogChain *arg1 = (wxLogChain *) 0 ;
13296 wxLog *arg2 = (wxLog *) 0 ;
13297 void *argp1 = 0 ;
13298 int res1 = 0 ;
13299 void *argp2 = 0 ;
13300 int res2 = 0 ;
13301 PyObject * obj0 = 0 ;
13302 PyObject * obj1 = 0 ;
13303 char * kwnames[] = {
13304 (char *) "self",(char *) "logger", NULL
13305 };
13306
13307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13309 if (!SWIG_IsOK(res1)) {
13310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13311 }
13312 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13314 if (!SWIG_IsOK(res2)) {
13315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13316 }
13317 arg2 = reinterpret_cast< wxLog * >(argp2);
13318 {
13319 PyThreadState* __tstate = wxPyBeginAllowThreads();
13320 (arg1)->SetLog(arg2);
13321 wxPyEndAllowThreads(__tstate);
13322 if (PyErr_Occurred()) SWIG_fail;
13323 }
13324 resultobj = SWIG_Py_Void();
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13332 PyObject *resultobj = 0;
13333 wxLogChain *arg1 = (wxLogChain *) 0 ;
13334 bool arg2 ;
13335 void *argp1 = 0 ;
13336 int res1 = 0 ;
13337 bool val2 ;
13338 int ecode2 = 0 ;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 char * kwnames[] = {
13342 (char *) "self",(char *) "bDoPass", NULL
13343 };
13344
13345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13347 if (!SWIG_IsOK(res1)) {
13348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13349 }
13350 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13351 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13352 if (!SWIG_IsOK(ecode2)) {
13353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13354 }
13355 arg2 = static_cast< bool >(val2);
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 (arg1)->PassMessages(arg2);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_Py_Void();
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13370 PyObject *resultobj = 0;
13371 wxLogChain *arg1 = (wxLogChain *) 0 ;
13372 bool result;
13373 void *argp1 = 0 ;
13374 int res1 = 0 ;
13375 PyObject *swig_obj[1] ;
13376
13377 if (!args) SWIG_fail;
13378 swig_obj[0] = args;
13379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13380 if (!SWIG_IsOK(res1)) {
13381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13382 }
13383 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13384 {
13385 PyThreadState* __tstate = wxPyBeginAllowThreads();
13386 result = (bool)(arg1)->IsPassingMessages();
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 {
13391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13392 }
13393 return resultobj;
13394 fail:
13395 return NULL;
13396 }
13397
13398
13399 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13400 PyObject *resultobj = 0;
13401 wxLogChain *arg1 = (wxLogChain *) 0 ;
13402 wxLog *result = 0 ;
13403 void *argp1 = 0 ;
13404 int res1 = 0 ;
13405 PyObject *swig_obj[1] ;
13406
13407 if (!args) SWIG_fail;
13408 swig_obj[0] = args;
13409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13410 if (!SWIG_IsOK(res1)) {
13411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13412 }
13413 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13414 {
13415 PyThreadState* __tstate = wxPyBeginAllowThreads();
13416 result = (wxLog *)(arg1)->GetOldLog();
13417 wxPyEndAllowThreads(__tstate);
13418 if (PyErr_Occurred()) SWIG_fail;
13419 }
13420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13421 return resultobj;
13422 fail:
13423 return NULL;
13424 }
13425
13426
13427 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13428 PyObject *obj;
13429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13430 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13431 return SWIG_Py_Void();
13432 }
13433
13434 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13435 return SWIG_Python_InitShadowInstance(args);
13436 }
13437
13438 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13439 PyObject *resultobj = 0;
13440 wxLogBuffer *result = 0 ;
13441
13442 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13443 {
13444 PyThreadState* __tstate = wxPyBeginAllowThreads();
13445 result = (wxLogBuffer *)new wxLogBuffer();
13446 wxPyEndAllowThreads(__tstate);
13447 if (PyErr_Occurred()) SWIG_fail;
13448 }
13449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13450 return resultobj;
13451 fail:
13452 return NULL;
13453 }
13454
13455
13456 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13457 PyObject *resultobj = 0;
13458 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13459 wxString *result = 0 ;
13460 void *argp1 = 0 ;
13461 int res1 = 0 ;
13462 PyObject *swig_obj[1] ;
13463
13464 if (!args) SWIG_fail;
13465 swig_obj[0] = args;
13466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13467 if (!SWIG_IsOK(res1)) {
13468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13469 }
13470 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13471 {
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 {
13474 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13475 result = (wxString *) &_result_ref;
13476 }
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 {
13481 #if wxUSE_UNICODE
13482 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13483 #else
13484 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13485 #endif
13486 }
13487 return resultobj;
13488 fail:
13489 return NULL;
13490 }
13491
13492
13493 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13494 PyObject *obj;
13495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13496 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13497 return SWIG_Py_Void();
13498 }
13499
13500 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13501 return SWIG_Python_InitShadowInstance(args);
13502 }
13503
13504 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13505 PyObject *resultobj = 0;
13506 unsigned long result;
13507
13508 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13509 {
13510 PyThreadState* __tstate = wxPyBeginAllowThreads();
13511 result = (unsigned long)wxSysErrorCode();
13512 wxPyEndAllowThreads(__tstate);
13513 if (PyErr_Occurred()) SWIG_fail;
13514 }
13515 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13516 return resultobj;
13517 fail:
13518 return NULL;
13519 }
13520
13521
13522 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13523 PyObject *resultobj = 0;
13524 unsigned long arg1 = (unsigned long) 0 ;
13525 wxString result;
13526 unsigned long val1 ;
13527 int ecode1 = 0 ;
13528 PyObject * obj0 = 0 ;
13529 char * kwnames[] = {
13530 (char *) "nErrCode", NULL
13531 };
13532
13533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13534 if (obj0) {
13535 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13536 if (!SWIG_IsOK(ecode1)) {
13537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13538 }
13539 arg1 = static_cast< unsigned long >(val1);
13540 }
13541 {
13542 PyThreadState* __tstate = wxPyBeginAllowThreads();
13543 result = wxSysErrorMsg(arg1);
13544 wxPyEndAllowThreads(__tstate);
13545 if (PyErr_Occurred()) SWIG_fail;
13546 }
13547 {
13548 #if wxUSE_UNICODE
13549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13550 #else
13551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13552 #endif
13553 }
13554 return resultobj;
13555 fail:
13556 return NULL;
13557 }
13558
13559
13560 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13561 PyObject *resultobj = 0;
13562 wxString *arg1 = 0 ;
13563 bool temp1 = false ;
13564 PyObject * obj0 = 0 ;
13565 char * kwnames[] = {
13566 (char *) "msg", NULL
13567 };
13568
13569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13570 {
13571 arg1 = wxString_in_helper(obj0);
13572 if (arg1 == NULL) SWIG_fail;
13573 temp1 = true;
13574 }
13575 {
13576 PyThreadState* __tstate = wxPyBeginAllowThreads();
13577 wxPyLogFatalError((wxString const &)*arg1);
13578 wxPyEndAllowThreads(__tstate);
13579 if (PyErr_Occurred()) SWIG_fail;
13580 }
13581 resultobj = SWIG_Py_Void();
13582 {
13583 if (temp1)
13584 delete arg1;
13585 }
13586 return resultobj;
13587 fail:
13588 {
13589 if (temp1)
13590 delete arg1;
13591 }
13592 return NULL;
13593 }
13594
13595
13596 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13597 PyObject *resultobj = 0;
13598 wxString *arg1 = 0 ;
13599 bool temp1 = false ;
13600 PyObject * obj0 = 0 ;
13601 char * kwnames[] = {
13602 (char *) "msg", NULL
13603 };
13604
13605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13606 {
13607 arg1 = wxString_in_helper(obj0);
13608 if (arg1 == NULL) SWIG_fail;
13609 temp1 = true;
13610 }
13611 {
13612 PyThreadState* __tstate = wxPyBeginAllowThreads();
13613 wxPyLogError((wxString const &)*arg1);
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 resultobj = SWIG_Py_Void();
13618 {
13619 if (temp1)
13620 delete arg1;
13621 }
13622 return resultobj;
13623 fail:
13624 {
13625 if (temp1)
13626 delete arg1;
13627 }
13628 return NULL;
13629 }
13630
13631
13632 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13633 PyObject *resultobj = 0;
13634 wxString *arg1 = 0 ;
13635 bool temp1 = false ;
13636 PyObject * obj0 = 0 ;
13637 char * kwnames[] = {
13638 (char *) "msg", NULL
13639 };
13640
13641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13642 {
13643 arg1 = wxString_in_helper(obj0);
13644 if (arg1 == NULL) SWIG_fail;
13645 temp1 = true;
13646 }
13647 {
13648 PyThreadState* __tstate = wxPyBeginAllowThreads();
13649 wxPyLogWarning((wxString const &)*arg1);
13650 wxPyEndAllowThreads(__tstate);
13651 if (PyErr_Occurred()) SWIG_fail;
13652 }
13653 resultobj = SWIG_Py_Void();
13654 {
13655 if (temp1)
13656 delete arg1;
13657 }
13658 return resultobj;
13659 fail:
13660 {
13661 if (temp1)
13662 delete arg1;
13663 }
13664 return NULL;
13665 }
13666
13667
13668 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13669 PyObject *resultobj = 0;
13670 wxString *arg1 = 0 ;
13671 bool temp1 = false ;
13672 PyObject * obj0 = 0 ;
13673 char * kwnames[] = {
13674 (char *) "msg", NULL
13675 };
13676
13677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13678 {
13679 arg1 = wxString_in_helper(obj0);
13680 if (arg1 == NULL) SWIG_fail;
13681 temp1 = true;
13682 }
13683 {
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 wxPyLogMessage((wxString const &)*arg1);
13686 wxPyEndAllowThreads(__tstate);
13687 if (PyErr_Occurred()) SWIG_fail;
13688 }
13689 resultobj = SWIG_Py_Void();
13690 {
13691 if (temp1)
13692 delete arg1;
13693 }
13694 return resultobj;
13695 fail:
13696 {
13697 if (temp1)
13698 delete arg1;
13699 }
13700 return NULL;
13701 }
13702
13703
13704 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj = 0;
13706 wxString *arg1 = 0 ;
13707 bool temp1 = false ;
13708 PyObject * obj0 = 0 ;
13709 char * kwnames[] = {
13710 (char *) "msg", NULL
13711 };
13712
13713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13714 {
13715 arg1 = wxString_in_helper(obj0);
13716 if (arg1 == NULL) SWIG_fail;
13717 temp1 = true;
13718 }
13719 {
13720 PyThreadState* __tstate = wxPyBeginAllowThreads();
13721 wxPyLogInfo((wxString const &)*arg1);
13722 wxPyEndAllowThreads(__tstate);
13723 if (PyErr_Occurred()) SWIG_fail;
13724 }
13725 resultobj = SWIG_Py_Void();
13726 {
13727 if (temp1)
13728 delete arg1;
13729 }
13730 return resultobj;
13731 fail:
13732 {
13733 if (temp1)
13734 delete arg1;
13735 }
13736 return NULL;
13737 }
13738
13739
13740 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13741 PyObject *resultobj = 0;
13742 wxString *arg1 = 0 ;
13743 bool temp1 = false ;
13744 PyObject * obj0 = 0 ;
13745 char * kwnames[] = {
13746 (char *) "msg", NULL
13747 };
13748
13749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13750 {
13751 arg1 = wxString_in_helper(obj0);
13752 if (arg1 == NULL) SWIG_fail;
13753 temp1 = true;
13754 }
13755 {
13756 PyThreadState* __tstate = wxPyBeginAllowThreads();
13757 wxPyLogDebug((wxString const &)*arg1);
13758 wxPyEndAllowThreads(__tstate);
13759 if (PyErr_Occurred()) SWIG_fail;
13760 }
13761 resultobj = SWIG_Py_Void();
13762 {
13763 if (temp1)
13764 delete arg1;
13765 }
13766 return resultobj;
13767 fail:
13768 {
13769 if (temp1)
13770 delete arg1;
13771 }
13772 return NULL;
13773 }
13774
13775
13776 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13777 PyObject *resultobj = 0;
13778 wxString *arg1 = 0 ;
13779 bool temp1 = false ;
13780 PyObject * obj0 = 0 ;
13781 char * kwnames[] = {
13782 (char *) "msg", NULL
13783 };
13784
13785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13786 {
13787 arg1 = wxString_in_helper(obj0);
13788 if (arg1 == NULL) SWIG_fail;
13789 temp1 = true;
13790 }
13791 {
13792 PyThreadState* __tstate = wxPyBeginAllowThreads();
13793 wxPyLogVerbose((wxString const &)*arg1);
13794 wxPyEndAllowThreads(__tstate);
13795 if (PyErr_Occurred()) SWIG_fail;
13796 }
13797 resultobj = SWIG_Py_Void();
13798 {
13799 if (temp1)
13800 delete arg1;
13801 }
13802 return resultobj;
13803 fail:
13804 {
13805 if (temp1)
13806 delete arg1;
13807 }
13808 return NULL;
13809 }
13810
13811
13812 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13813 PyObject *resultobj = 0;
13814 wxString *arg1 = 0 ;
13815 bool temp1 = false ;
13816 PyObject * obj0 = 0 ;
13817 char * kwnames[] = {
13818 (char *) "msg", NULL
13819 };
13820
13821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13822 {
13823 arg1 = wxString_in_helper(obj0);
13824 if (arg1 == NULL) SWIG_fail;
13825 temp1 = true;
13826 }
13827 {
13828 PyThreadState* __tstate = wxPyBeginAllowThreads();
13829 wxPyLogStatus((wxString const &)*arg1);
13830 wxPyEndAllowThreads(__tstate);
13831 if (PyErr_Occurred()) SWIG_fail;
13832 }
13833 resultobj = SWIG_Py_Void();
13834 {
13835 if (temp1)
13836 delete arg1;
13837 }
13838 return resultobj;
13839 fail:
13840 {
13841 if (temp1)
13842 delete arg1;
13843 }
13844 return NULL;
13845 }
13846
13847
13848 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13849 PyObject *resultobj = 0;
13850 wxFrame *arg1 = (wxFrame *) 0 ;
13851 wxString *arg2 = 0 ;
13852 void *argp1 = 0 ;
13853 int res1 = 0 ;
13854 bool temp2 = false ;
13855 PyObject * obj0 = 0 ;
13856 PyObject * obj1 = 0 ;
13857 char * kwnames[] = {
13858 (char *) "pFrame",(char *) "msg", NULL
13859 };
13860
13861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13863 if (!SWIG_IsOK(res1)) {
13864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13865 }
13866 arg1 = reinterpret_cast< wxFrame * >(argp1);
13867 {
13868 arg2 = wxString_in_helper(obj1);
13869 if (arg2 == NULL) SWIG_fail;
13870 temp2 = true;
13871 }
13872 {
13873 PyThreadState* __tstate = wxPyBeginAllowThreads();
13874 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13875 wxPyEndAllowThreads(__tstate);
13876 if (PyErr_Occurred()) SWIG_fail;
13877 }
13878 resultobj = SWIG_Py_Void();
13879 {
13880 if (temp2)
13881 delete arg2;
13882 }
13883 return resultobj;
13884 fail:
13885 {
13886 if (temp2)
13887 delete arg2;
13888 }
13889 return NULL;
13890 }
13891
13892
13893 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13894 PyObject *resultobj = 0;
13895 wxString *arg1 = 0 ;
13896 bool temp1 = false ;
13897 PyObject * obj0 = 0 ;
13898 char * kwnames[] = {
13899 (char *) "msg", NULL
13900 };
13901
13902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13903 {
13904 arg1 = wxString_in_helper(obj0);
13905 if (arg1 == NULL) SWIG_fail;
13906 temp1 = true;
13907 }
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 wxPyLogSysError((wxString const &)*arg1);
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_Py_Void();
13915 {
13916 if (temp1)
13917 delete arg1;
13918 }
13919 return resultobj;
13920 fail:
13921 {
13922 if (temp1)
13923 delete arg1;
13924 }
13925 return NULL;
13926 }
13927
13928
13929 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13930 PyObject *resultobj = 0;
13931 unsigned long arg1 ;
13932 wxString *arg2 = 0 ;
13933 unsigned long val1 ;
13934 int ecode1 = 0 ;
13935 bool temp2 = false ;
13936 PyObject * obj0 = 0 ;
13937 PyObject * obj1 = 0 ;
13938 char * kwnames[] = {
13939 (char *) "level",(char *) "msg", NULL
13940 };
13941
13942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13943 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13944 if (!SWIG_IsOK(ecode1)) {
13945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13946 }
13947 arg1 = static_cast< unsigned long >(val1);
13948 {
13949 arg2 = wxString_in_helper(obj1);
13950 if (arg2 == NULL) SWIG_fail;
13951 temp2 = true;
13952 }
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13956 wxPyEndAllowThreads(__tstate);
13957 if (PyErr_Occurred()) SWIG_fail;
13958 }
13959 resultobj = SWIG_Py_Void();
13960 {
13961 if (temp2)
13962 delete arg2;
13963 }
13964 return resultobj;
13965 fail:
13966 {
13967 if (temp2)
13968 delete arg2;
13969 }
13970 return NULL;
13971 }
13972
13973
13974 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13975 PyObject *resultobj = 0;
13976 unsigned long arg1 ;
13977 wxString *arg2 = 0 ;
13978 unsigned long val1 ;
13979 int ecode1 = 0 ;
13980 bool temp2 = false ;
13981
13982 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13983 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13984 if (!SWIG_IsOK(ecode1)) {
13985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13986 }
13987 arg1 = static_cast< unsigned long >(val1);
13988 {
13989 arg2 = wxString_in_helper(swig_obj[1]);
13990 if (arg2 == NULL) SWIG_fail;
13991 temp2 = true;
13992 }
13993 {
13994 PyThreadState* __tstate = wxPyBeginAllowThreads();
13995 wxPyLogTrace(arg1,(wxString const &)*arg2);
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 resultobj = SWIG_Py_Void();
14000 {
14001 if (temp2)
14002 delete arg2;
14003 }
14004 return resultobj;
14005 fail:
14006 {
14007 if (temp2)
14008 delete arg2;
14009 }
14010 return NULL;
14011 }
14012
14013
14014 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
14015 PyObject *resultobj = 0;
14016 wxString *arg1 = 0 ;
14017 wxString *arg2 = 0 ;
14018 bool temp1 = false ;
14019 bool temp2 = false ;
14020
14021 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14022 {
14023 arg1 = wxString_in_helper(swig_obj[0]);
14024 if (arg1 == NULL) SWIG_fail;
14025 temp1 = true;
14026 }
14027 {
14028 arg2 = wxString_in_helper(swig_obj[1]);
14029 if (arg2 == NULL) SWIG_fail;
14030 temp2 = true;
14031 }
14032 {
14033 PyThreadState* __tstate = wxPyBeginAllowThreads();
14034 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 resultobj = SWIG_Py_Void();
14039 {
14040 if (temp1)
14041 delete arg1;
14042 }
14043 {
14044 if (temp2)
14045 delete arg2;
14046 }
14047 return resultobj;
14048 fail:
14049 {
14050 if (temp1)
14051 delete arg1;
14052 }
14053 {
14054 if (temp2)
14055 delete arg2;
14056 }
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14062 int argc;
14063 PyObject *argv[3];
14064
14065 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14066 --argc;
14067 if (argc == 2) {
14068 int _v = 0;
14069 {
14070 {
14071 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14072 }
14073 }
14074 if (!_v) goto check_1;
14075 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14076 }
14077 check_1:
14078
14079 if (argc == 2) {
14080 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14081 }
14082
14083 fail:
14084 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxString *arg1 = 0 ;
14092 wxString *arg2 = 0 ;
14093 bool temp1 = false ;
14094 bool temp2 = false ;
14095 PyObject * obj0 = 0 ;
14096 PyObject * obj1 = 0 ;
14097 char * kwnames[] = {
14098 (char *) "title",(char *) "text", NULL
14099 };
14100
14101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14102 {
14103 arg1 = wxString_in_helper(obj0);
14104 if (arg1 == NULL) SWIG_fail;
14105 temp1 = true;
14106 }
14107 {
14108 arg2 = wxString_in_helper(obj1);
14109 if (arg2 == NULL) SWIG_fail;
14110 temp2 = true;
14111 }
14112 {
14113 PyThreadState* __tstate = wxPyBeginAllowThreads();
14114 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14115 wxPyEndAllowThreads(__tstate);
14116 if (PyErr_Occurred()) SWIG_fail;
14117 }
14118 resultobj = SWIG_Py_Void();
14119 {
14120 if (temp1)
14121 delete arg1;
14122 }
14123 {
14124 if (temp2)
14125 delete arg2;
14126 }
14127 return resultobj;
14128 fail:
14129 {
14130 if (temp1)
14131 delete arg1;
14132 }
14133 {
14134 if (temp2)
14135 delete arg2;
14136 }
14137 return NULL;
14138 }
14139
14140
14141 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14142 PyObject *resultobj = 0;
14143 wxLogNull *result = 0 ;
14144
14145 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14146 {
14147 PyThreadState* __tstate = wxPyBeginAllowThreads();
14148 result = (wxLogNull *)new wxLogNull();
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14160 PyObject *resultobj = 0;
14161 wxLogNull *arg1 = (wxLogNull *) 0 ;
14162 void *argp1 = 0 ;
14163 int res1 = 0 ;
14164 PyObject *swig_obj[1] ;
14165
14166 if (!args) SWIG_fail;
14167 swig_obj[0] = args;
14168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14169 if (!SWIG_IsOK(res1)) {
14170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14171 }
14172 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 delete arg1;
14176
14177 wxPyEndAllowThreads(__tstate);
14178 if (PyErr_Occurred()) SWIG_fail;
14179 }
14180 resultobj = SWIG_Py_Void();
14181 return resultobj;
14182 fail:
14183 return NULL;
14184 }
14185
14186
14187 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14188 PyObject *obj;
14189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14190 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14191 return SWIG_Py_Void();
14192 }
14193
14194 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14195 return SWIG_Python_InitShadowInstance(args);
14196 }
14197
14198 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14199 PyObject *resultobj = 0;
14200 wxPyLog *result = 0 ;
14201
14202 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14203 {
14204 PyThreadState* __tstate = wxPyBeginAllowThreads();
14205 result = (wxPyLog *)new wxPyLog();
14206 wxPyEndAllowThreads(__tstate);
14207 if (PyErr_Occurred()) SWIG_fail;
14208 }
14209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj = 0;
14218 wxPyLog *arg1 = (wxPyLog *) 0 ;
14219 PyObject *arg2 = (PyObject *) 0 ;
14220 PyObject *arg3 = (PyObject *) 0 ;
14221 void *argp1 = 0 ;
14222 int res1 = 0 ;
14223 PyObject * obj0 = 0 ;
14224 PyObject * obj1 = 0 ;
14225 PyObject * obj2 = 0 ;
14226 char * kwnames[] = {
14227 (char *) "self",(char *) "self",(char *) "_class", NULL
14228 };
14229
14230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14232 if (!SWIG_IsOK(res1)) {
14233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14234 }
14235 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14236 arg2 = obj1;
14237 arg3 = obj2;
14238 {
14239 PyThreadState* __tstate = wxPyBeginAllowThreads();
14240 (arg1)->_setCallbackInfo(arg2,arg3);
14241 wxPyEndAllowThreads(__tstate);
14242 if (PyErr_Occurred()) SWIG_fail;
14243 }
14244 resultobj = SWIG_Py_Void();
14245 return resultobj;
14246 fail:
14247 return NULL;
14248 }
14249
14250
14251 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14252 PyObject *obj;
14253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14254 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14255 return SWIG_Py_Void();
14256 }
14257
14258 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14259 return SWIG_Python_InitShadowInstance(args);
14260 }
14261
14262 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14263 PyObject *resultobj = 0;
14264 int arg1 ;
14265 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14266 int arg3 = (int) wxKILL_NOCHILDREN ;
14267 wxKillError result;
14268 int val1 ;
14269 int ecode1 = 0 ;
14270 int val2 ;
14271 int ecode2 = 0 ;
14272 int val3 ;
14273 int ecode3 = 0 ;
14274 PyObject * obj0 = 0 ;
14275 PyObject * obj1 = 0 ;
14276 PyObject * obj2 = 0 ;
14277 char * kwnames[] = {
14278 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14279 };
14280
14281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14282 ecode1 = SWIG_AsVal_int(obj0, &val1);
14283 if (!SWIG_IsOK(ecode1)) {
14284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14285 }
14286 arg1 = static_cast< int >(val1);
14287 if (obj1) {
14288 ecode2 = SWIG_AsVal_int(obj1, &val2);
14289 if (!SWIG_IsOK(ecode2)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14291 }
14292 arg2 = static_cast< wxSignal >(val2);
14293 }
14294 if (obj2) {
14295 ecode3 = SWIG_AsVal_int(obj2, &val3);
14296 if (!SWIG_IsOK(ecode3)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14298 }
14299 arg3 = static_cast< int >(val3);
14300 }
14301 {
14302 PyThreadState* __tstate = wxPyBeginAllowThreads();
14303 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 resultobj = SWIG_From_int(static_cast< int >(result));
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14315 PyObject *resultobj = 0;
14316 int arg1 ;
14317 bool result;
14318 int val1 ;
14319 int ecode1 = 0 ;
14320 PyObject * obj0 = 0 ;
14321 char * kwnames[] = {
14322 (char *) "pid", NULL
14323 };
14324
14325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14326 ecode1 = SWIG_AsVal_int(obj0, &val1);
14327 if (!SWIG_IsOK(ecode1)) {
14328 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14329 }
14330 arg1 = static_cast< int >(val1);
14331 {
14332 PyThreadState* __tstate = wxPyBeginAllowThreads();
14333 result = (bool)wxPyProcess::Exists(arg1);
14334 wxPyEndAllowThreads(__tstate);
14335 if (PyErr_Occurred()) SWIG_fail;
14336 }
14337 {
14338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14339 }
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj = 0;
14348 wxString *arg1 = 0 ;
14349 int arg2 = (int) wxEXEC_ASYNC ;
14350 wxPyProcess *result = 0 ;
14351 bool temp1 = false ;
14352 int val2 ;
14353 int ecode2 = 0 ;
14354 PyObject * obj0 = 0 ;
14355 PyObject * obj1 = 0 ;
14356 char * kwnames[] = {
14357 (char *) "cmd",(char *) "flags", NULL
14358 };
14359
14360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14361 {
14362 arg1 = wxString_in_helper(obj0);
14363 if (arg1 == NULL) SWIG_fail;
14364 temp1 = true;
14365 }
14366 if (obj1) {
14367 ecode2 = SWIG_AsVal_int(obj1, &val2);
14368 if (!SWIG_IsOK(ecode2)) {
14369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14370 }
14371 arg2 = static_cast< int >(val2);
14372 }
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14376 wxPyEndAllowThreads(__tstate);
14377 if (PyErr_Occurred()) SWIG_fail;
14378 }
14379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14380 {
14381 if (temp1)
14382 delete arg1;
14383 }
14384 return resultobj;
14385 fail:
14386 {
14387 if (temp1)
14388 delete arg1;
14389 }
14390 return NULL;
14391 }
14392
14393
14394 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14395 PyObject *resultobj = 0;
14396 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14397 int arg2 = (int) -1 ;
14398 wxPyProcess *result = 0 ;
14399 void *argp1 = 0 ;
14400 int res1 = 0 ;
14401 int val2 ;
14402 int ecode2 = 0 ;
14403 PyObject * obj0 = 0 ;
14404 PyObject * obj1 = 0 ;
14405 char * kwnames[] = {
14406 (char *) "parent",(char *) "id", NULL
14407 };
14408
14409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14410 if (obj0) {
14411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14412 if (!SWIG_IsOK(res1)) {
14413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14414 }
14415 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14416 }
14417 if (obj1) {
14418 ecode2 = SWIG_AsVal_int(obj1, &val2);
14419 if (!SWIG_IsOK(ecode2)) {
14420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14421 }
14422 arg2 = static_cast< int >(val2);
14423 }
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14438 PyObject *resultobj = 0;
14439 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14440 void *argp1 = 0 ;
14441 int res1 = 0 ;
14442 PyObject *swig_obj[1] ;
14443
14444 if (!args) SWIG_fail;
14445 swig_obj[0] = args;
14446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14447 if (!SWIG_IsOK(res1)) {
14448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14449 }
14450 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14451 {
14452 PyThreadState* __tstate = wxPyBeginAllowThreads();
14453 delete arg1;
14454
14455 wxPyEndAllowThreads(__tstate);
14456 if (PyErr_Occurred()) SWIG_fail;
14457 }
14458 resultobj = SWIG_Py_Void();
14459 return resultobj;
14460 fail:
14461 return NULL;
14462 }
14463
14464
14465 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14466 PyObject *resultobj = 0;
14467 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14468 PyObject *arg2 = (PyObject *) 0 ;
14469 PyObject *arg3 = (PyObject *) 0 ;
14470 void *argp1 = 0 ;
14471 int res1 = 0 ;
14472 PyObject * obj0 = 0 ;
14473 PyObject * obj1 = 0 ;
14474 PyObject * obj2 = 0 ;
14475 char * kwnames[] = {
14476 (char *) "self",(char *) "self",(char *) "_class", NULL
14477 };
14478
14479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14481 if (!SWIG_IsOK(res1)) {
14482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14483 }
14484 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14485 arg2 = obj1;
14486 arg3 = obj2;
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 (arg1)->_setCallbackInfo(arg2,arg3);
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 resultobj = SWIG_Py_Void();
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14501 PyObject *resultobj = 0;
14502 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14503 long result;
14504 void *argp1 = 0 ;
14505 int res1 = 0 ;
14506 PyObject *swig_obj[1] ;
14507
14508 if (!args) SWIG_fail;
14509 swig_obj[0] = args;
14510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14511 if (!SWIG_IsOK(res1)) {
14512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14513 }
14514 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 result = (long)((wxPyProcess const *)arg1)->GetPid();
14518 wxPyEndAllowThreads(__tstate);
14519 if (PyErr_Occurred()) SWIG_fail;
14520 }
14521 resultobj = SWIG_From_long(static_cast< long >(result));
14522 return resultobj;
14523 fail:
14524 return NULL;
14525 }
14526
14527
14528 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj = 0;
14530 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14531 int arg2 ;
14532 int arg3 ;
14533 void *argp1 = 0 ;
14534 int res1 = 0 ;
14535 int val2 ;
14536 int ecode2 = 0 ;
14537 int val3 ;
14538 int ecode3 = 0 ;
14539 PyObject * obj0 = 0 ;
14540 PyObject * obj1 = 0 ;
14541 PyObject * obj2 = 0 ;
14542 char * kwnames[] = {
14543 (char *) "self",(char *) "pid",(char *) "status", NULL
14544 };
14545
14546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14548 if (!SWIG_IsOK(res1)) {
14549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14550 }
14551 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14552 ecode2 = SWIG_AsVal_int(obj1, &val2);
14553 if (!SWIG_IsOK(ecode2)) {
14554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14555 }
14556 arg2 = static_cast< int >(val2);
14557 ecode3 = SWIG_AsVal_int(obj2, &val3);
14558 if (!SWIG_IsOK(ecode3)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14560 }
14561 arg3 = static_cast< int >(val3);
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 (arg1)->OnTerminate(arg2,arg3);
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 resultobj = SWIG_Py_Void();
14569 return resultobj;
14570 fail:
14571 return NULL;
14572 }
14573
14574
14575 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14576 PyObject *resultobj = 0;
14577 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14578 void *argp1 = 0 ;
14579 int res1 = 0 ;
14580 PyObject *swig_obj[1] ;
14581
14582 if (!args) SWIG_fail;
14583 swig_obj[0] = args;
14584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14585 if (!SWIG_IsOK(res1)) {
14586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14587 }
14588 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 (arg1)->Redirect();
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = SWIG_Py_Void();
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14603 PyObject *resultobj = 0;
14604 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14605 bool result;
14606 void *argp1 = 0 ;
14607 int res1 = 0 ;
14608 PyObject *swig_obj[1] ;
14609
14610 if (!args) SWIG_fail;
14611 swig_obj[0] = args;
14612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14613 if (!SWIG_IsOK(res1)) {
14614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14615 }
14616 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14617 {
14618 PyThreadState* __tstate = wxPyBeginAllowThreads();
14619 result = (bool)(arg1)->IsRedirected();
14620 wxPyEndAllowThreads(__tstate);
14621 if (PyErr_Occurred()) SWIG_fail;
14622 }
14623 {
14624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14625 }
14626 return resultobj;
14627 fail:
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14633 PyObject *resultobj = 0;
14634 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14635 void *argp1 = 0 ;
14636 int res1 = 0 ;
14637 PyObject *swig_obj[1] ;
14638
14639 if (!args) SWIG_fail;
14640 swig_obj[0] = args;
14641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14642 if (!SWIG_IsOK(res1)) {
14643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14644 }
14645 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14646 {
14647 PyThreadState* __tstate = wxPyBeginAllowThreads();
14648 (arg1)->Detach();
14649 wxPyEndAllowThreads(__tstate);
14650 if (PyErr_Occurred()) SWIG_fail;
14651 }
14652 resultobj = SWIG_Py_Void();
14653 return resultobj;
14654 fail:
14655 return NULL;
14656 }
14657
14658
14659 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14660 PyObject *resultobj = 0;
14661 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14662 wxInputStream *result = 0 ;
14663 void *argp1 = 0 ;
14664 int res1 = 0 ;
14665 PyObject *swig_obj[1] ;
14666
14667 if (!args) SWIG_fail;
14668 swig_obj[0] = args;
14669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14670 if (!SWIG_IsOK(res1)) {
14671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14672 }
14673 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (wxInputStream *)(arg1)->GetInputStream();
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 {
14681 wxPyInputStream * _ptr = NULL;
14682
14683 if (result) {
14684 _ptr = new wxPyInputStream(result);
14685 }
14686 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14687 }
14688 return resultobj;
14689 fail:
14690 return NULL;
14691 }
14692
14693
14694 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14695 PyObject *resultobj = 0;
14696 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14697 wxInputStream *result = 0 ;
14698 void *argp1 = 0 ;
14699 int res1 = 0 ;
14700 PyObject *swig_obj[1] ;
14701
14702 if (!args) SWIG_fail;
14703 swig_obj[0] = args;
14704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14705 if (!SWIG_IsOK(res1)) {
14706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14707 }
14708 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14709 {
14710 PyThreadState* __tstate = wxPyBeginAllowThreads();
14711 result = (wxInputStream *)(arg1)->GetErrorStream();
14712 wxPyEndAllowThreads(__tstate);
14713 if (PyErr_Occurred()) SWIG_fail;
14714 }
14715 {
14716 wxPyInputStream * _ptr = NULL;
14717
14718 if (result) {
14719 _ptr = new wxPyInputStream(result);
14720 }
14721 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14722 }
14723 return resultobj;
14724 fail:
14725 return NULL;
14726 }
14727
14728
14729 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14730 PyObject *resultobj = 0;
14731 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14732 wxOutputStream *result = 0 ;
14733 void *argp1 = 0 ;
14734 int res1 = 0 ;
14735 PyObject *swig_obj[1] ;
14736
14737 if (!args) SWIG_fail;
14738 swig_obj[0] = args;
14739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14740 if (!SWIG_IsOK(res1)) {
14741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14742 }
14743 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14744 {
14745 PyThreadState* __tstate = wxPyBeginAllowThreads();
14746 result = (wxOutputStream *)(arg1)->GetOutputStream();
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14751 return resultobj;
14752 fail:
14753 return NULL;
14754 }
14755
14756
14757 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14758 PyObject *resultobj = 0;
14759 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14760 void *argp1 = 0 ;
14761 int res1 = 0 ;
14762 PyObject *swig_obj[1] ;
14763
14764 if (!args) SWIG_fail;
14765 swig_obj[0] = args;
14766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14767 if (!SWIG_IsOK(res1)) {
14768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14769 }
14770 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14771 {
14772 PyThreadState* __tstate = wxPyBeginAllowThreads();
14773 (arg1)->CloseOutput();
14774 wxPyEndAllowThreads(__tstate);
14775 if (PyErr_Occurred()) SWIG_fail;
14776 }
14777 resultobj = SWIG_Py_Void();
14778 return resultobj;
14779 fail:
14780 return NULL;
14781 }
14782
14783
14784 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14785 PyObject *resultobj = 0;
14786 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14787 bool result;
14788 void *argp1 = 0 ;
14789 int res1 = 0 ;
14790 PyObject *swig_obj[1] ;
14791
14792 if (!args) SWIG_fail;
14793 swig_obj[0] = args;
14794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14795 if (!SWIG_IsOK(res1)) {
14796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14797 }
14798 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14799 {
14800 PyThreadState* __tstate = wxPyBeginAllowThreads();
14801 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14802 wxPyEndAllowThreads(__tstate);
14803 if (PyErr_Occurred()) SWIG_fail;
14804 }
14805 {
14806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14807 }
14808 return resultobj;
14809 fail:
14810 return NULL;
14811 }
14812
14813
14814 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14815 PyObject *resultobj = 0;
14816 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14817 bool result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 PyObject *swig_obj[1] ;
14821
14822 if (!args) SWIG_fail;
14823 swig_obj[0] = args;
14824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14825 if (!SWIG_IsOK(res1)) {
14826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14827 }
14828 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14829 {
14830 PyThreadState* __tstate = wxPyBeginAllowThreads();
14831 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14832 wxPyEndAllowThreads(__tstate);
14833 if (PyErr_Occurred()) SWIG_fail;
14834 }
14835 {
14836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14837 }
14838 return resultobj;
14839 fail:
14840 return NULL;
14841 }
14842
14843
14844 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14845 PyObject *resultobj = 0;
14846 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14847 bool result;
14848 void *argp1 = 0 ;
14849 int res1 = 0 ;
14850 PyObject *swig_obj[1] ;
14851
14852 if (!args) SWIG_fail;
14853 swig_obj[0] = args;
14854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14855 if (!SWIG_IsOK(res1)) {
14856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14857 }
14858 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 {
14866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14867 }
14868 return resultobj;
14869 fail:
14870 return NULL;
14871 }
14872
14873
14874 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14875 PyObject *obj;
14876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14877 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14878 return SWIG_Py_Void();
14879 }
14880
14881 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14882 return SWIG_Python_InitShadowInstance(args);
14883 }
14884
14885 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14886 PyObject *resultobj = 0;
14887 int arg1 = (int) 0 ;
14888 int arg2 = (int) 0 ;
14889 int arg3 = (int) 0 ;
14890 wxProcessEvent *result = 0 ;
14891 int val1 ;
14892 int ecode1 = 0 ;
14893 int val2 ;
14894 int ecode2 = 0 ;
14895 int val3 ;
14896 int ecode3 = 0 ;
14897 PyObject * obj0 = 0 ;
14898 PyObject * obj1 = 0 ;
14899 PyObject * obj2 = 0 ;
14900 char * kwnames[] = {
14901 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14902 };
14903
14904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14905 if (obj0) {
14906 ecode1 = SWIG_AsVal_int(obj0, &val1);
14907 if (!SWIG_IsOK(ecode1)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14909 }
14910 arg1 = static_cast< int >(val1);
14911 }
14912 if (obj1) {
14913 ecode2 = SWIG_AsVal_int(obj1, &val2);
14914 if (!SWIG_IsOK(ecode2)) {
14915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14916 }
14917 arg2 = static_cast< int >(val2);
14918 }
14919 if (obj2) {
14920 ecode3 = SWIG_AsVal_int(obj2, &val3);
14921 if (!SWIG_IsOK(ecode3)) {
14922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14923 }
14924 arg3 = static_cast< int >(val3);
14925 }
14926 {
14927 PyThreadState* __tstate = wxPyBeginAllowThreads();
14928 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14933 return resultobj;
14934 fail:
14935 return NULL;
14936 }
14937
14938
14939 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14940 PyObject *resultobj = 0;
14941 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14942 int result;
14943 void *argp1 = 0 ;
14944 int res1 = 0 ;
14945 PyObject *swig_obj[1] ;
14946
14947 if (!args) SWIG_fail;
14948 swig_obj[0] = args;
14949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14950 if (!SWIG_IsOK(res1)) {
14951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14952 }
14953 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 result = (int)(arg1)->GetPid();
14957 wxPyEndAllowThreads(__tstate);
14958 if (PyErr_Occurred()) SWIG_fail;
14959 }
14960 resultobj = SWIG_From_int(static_cast< int >(result));
14961 return resultobj;
14962 fail:
14963 return NULL;
14964 }
14965
14966
14967 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14968 PyObject *resultobj = 0;
14969 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14970 int result;
14971 void *argp1 = 0 ;
14972 int res1 = 0 ;
14973 PyObject *swig_obj[1] ;
14974
14975 if (!args) SWIG_fail;
14976 swig_obj[0] = args;
14977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14978 if (!SWIG_IsOK(res1)) {
14979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14980 }
14981 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14982 {
14983 PyThreadState* __tstate = wxPyBeginAllowThreads();
14984 result = (int)(arg1)->GetExitCode();
14985 wxPyEndAllowThreads(__tstate);
14986 if (PyErr_Occurred()) SWIG_fail;
14987 }
14988 resultobj = SWIG_From_int(static_cast< int >(result));
14989 return resultobj;
14990 fail:
14991 return NULL;
14992 }
14993
14994
14995 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14996 PyObject *resultobj = 0;
14997 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14998 int arg2 ;
14999 void *argp1 = 0 ;
15000 int res1 = 0 ;
15001 int val2 ;
15002 int ecode2 = 0 ;
15003 PyObject *swig_obj[2] ;
15004
15005 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
15006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15007 if (!SWIG_IsOK(res1)) {
15008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15009 }
15010 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15011 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15012 if (!SWIG_IsOK(ecode2)) {
15013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
15014 }
15015 arg2 = static_cast< int >(val2);
15016 if (arg1) (arg1)->m_pid = arg2;
15017
15018 resultobj = SWIG_Py_Void();
15019 return resultobj;
15020 fail:
15021 return NULL;
15022 }
15023
15024
15025 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15026 PyObject *resultobj = 0;
15027 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15028 int result;
15029 void *argp1 = 0 ;
15030 int res1 = 0 ;
15031 PyObject *swig_obj[1] ;
15032
15033 if (!args) SWIG_fail;
15034 swig_obj[0] = args;
15035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15036 if (!SWIG_IsOK(res1)) {
15037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15038 }
15039 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15040 result = (int) ((arg1)->m_pid);
15041 resultobj = SWIG_From_int(static_cast< int >(result));
15042 return resultobj;
15043 fail:
15044 return NULL;
15045 }
15046
15047
15048 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15049 PyObject *resultobj = 0;
15050 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15051 int arg2 ;
15052 void *argp1 = 0 ;
15053 int res1 = 0 ;
15054 int val2 ;
15055 int ecode2 = 0 ;
15056 PyObject *swig_obj[2] ;
15057
15058 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15060 if (!SWIG_IsOK(res1)) {
15061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15062 }
15063 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15064 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15065 if (!SWIG_IsOK(ecode2)) {
15066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15067 }
15068 arg2 = static_cast< int >(val2);
15069 if (arg1) (arg1)->m_exitcode = arg2;
15070
15071 resultobj = SWIG_Py_Void();
15072 return resultobj;
15073 fail:
15074 return NULL;
15075 }
15076
15077
15078 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15079 PyObject *resultobj = 0;
15080 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15081 int result;
15082 void *argp1 = 0 ;
15083 int res1 = 0 ;
15084 PyObject *swig_obj[1] ;
15085
15086 if (!args) SWIG_fail;
15087 swig_obj[0] = args;
15088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15089 if (!SWIG_IsOK(res1)) {
15090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15091 }
15092 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15093 result = (int) ((arg1)->m_exitcode);
15094 resultobj = SWIG_From_int(static_cast< int >(result));
15095 return resultobj;
15096 fail:
15097 return NULL;
15098 }
15099
15100
15101 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15102 PyObject *obj;
15103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15104 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15105 return SWIG_Py_Void();
15106 }
15107
15108 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15109 return SWIG_Python_InitShadowInstance(args);
15110 }
15111
15112 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15113 PyObject *resultobj = 0;
15114 wxString *arg1 = 0 ;
15115 int arg2 = (int) wxEXEC_ASYNC ;
15116 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15117 long result;
15118 bool temp1 = false ;
15119 int val2 ;
15120 int ecode2 = 0 ;
15121 void *argp3 = 0 ;
15122 int res3 = 0 ;
15123 PyObject * obj0 = 0 ;
15124 PyObject * obj1 = 0 ;
15125 PyObject * obj2 = 0 ;
15126 char * kwnames[] = {
15127 (char *) "command",(char *) "flags",(char *) "process", NULL
15128 };
15129
15130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15131 {
15132 arg1 = wxString_in_helper(obj0);
15133 if (arg1 == NULL) SWIG_fail;
15134 temp1 = true;
15135 }
15136 if (obj1) {
15137 ecode2 = SWIG_AsVal_int(obj1, &val2);
15138 if (!SWIG_IsOK(ecode2)) {
15139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15140 }
15141 arg2 = static_cast< int >(val2);
15142 }
15143 if (obj2) {
15144 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15145 if (!SWIG_IsOK(res3)) {
15146 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15147 }
15148 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15149 }
15150 {
15151 if (!wxPyCheckForApp()) SWIG_fail;
15152 PyThreadState* __tstate = wxPyBeginAllowThreads();
15153 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15154 wxPyEndAllowThreads(__tstate);
15155 if (PyErr_Occurred()) SWIG_fail;
15156 }
15157 resultobj = SWIG_From_long(static_cast< long >(result));
15158 {
15159 if (temp1)
15160 delete arg1;
15161 }
15162 return resultobj;
15163 fail:
15164 {
15165 if (temp1)
15166 delete arg1;
15167 }
15168 return NULL;
15169 }
15170
15171
15172 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15173 PyObject *resultobj = 0;
15174 long arg1 ;
15175 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15176 wxKillError *arg3 = (wxKillError *) 0 ;
15177 int arg4 = (int) wxKILL_NOCHILDREN ;
15178 int result;
15179 long val1 ;
15180 int ecode1 = 0 ;
15181 int val2 ;
15182 int ecode2 = 0 ;
15183 wxKillError temp3 ;
15184 int val4 ;
15185 int ecode4 = 0 ;
15186 PyObject * obj0 = 0 ;
15187 PyObject * obj1 = 0 ;
15188 PyObject * obj2 = 0 ;
15189 char * kwnames[] = {
15190 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15191 };
15192
15193 {
15194 arg3 = &temp3;
15195 }
15196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15197 ecode1 = SWIG_AsVal_long(obj0, &val1);
15198 if (!SWIG_IsOK(ecode1)) {
15199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15200 }
15201 arg1 = static_cast< long >(val1);
15202 if (obj1) {
15203 ecode2 = SWIG_AsVal_int(obj1, &val2);
15204 if (!SWIG_IsOK(ecode2)) {
15205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15206 }
15207 arg2 = static_cast< wxSignal >(val2);
15208 }
15209 if (obj2) {
15210 ecode4 = SWIG_AsVal_int(obj2, &val4);
15211 if (!SWIG_IsOK(ecode4)) {
15212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15213 }
15214 arg4 = static_cast< int >(val4);
15215 }
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (int)wxKill(arg1,arg2,arg3,arg4);
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_From_int(static_cast< int >(result));
15223 {
15224 PyObject* o;
15225 o = PyInt_FromLong((long) (*arg3));
15226
15227
15228
15229 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15230
15231 }
15232 return resultobj;
15233 fail:
15234 return NULL;
15235 }
15236
15237
15238 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15239 PyObject *resultobj = 0;
15240 int arg1 = (int) wxJOYSTICK1 ;
15241 wxJoystick *result = 0 ;
15242 int val1 ;
15243 int ecode1 = 0 ;
15244 PyObject * obj0 = 0 ;
15245 char * kwnames[] = {
15246 (char *) "joystick", NULL
15247 };
15248
15249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15250 if (obj0) {
15251 ecode1 = SWIG_AsVal_int(obj0, &val1);
15252 if (!SWIG_IsOK(ecode1)) {
15253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15254 }
15255 arg1 = static_cast< int >(val1);
15256 }
15257 {
15258 if (!wxPyCheckForApp()) SWIG_fail;
15259 PyThreadState* __tstate = wxPyBeginAllowThreads();
15260 result = (wxJoystick *)new wxJoystick(arg1);
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15265 return resultobj;
15266 fail:
15267 return NULL;
15268 }
15269
15270
15271 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15272 PyObject *resultobj = 0;
15273 wxJoystick *arg1 = (wxJoystick *) 0 ;
15274 void *argp1 = 0 ;
15275 int res1 = 0 ;
15276 PyObject *swig_obj[1] ;
15277
15278 if (!args) SWIG_fail;
15279 swig_obj[0] = args;
15280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15281 if (!SWIG_IsOK(res1)) {
15282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15283 }
15284 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 delete arg1;
15288
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_Py_Void();
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300 PyObject *resultobj = 0;
15301 wxJoystick *arg1 = (wxJoystick *) 0 ;
15302 wxPoint result;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 PyObject *swig_obj[1] ;
15306
15307 if (!args) SWIG_fail;
15308 swig_obj[0] = args;
15309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15310 if (!SWIG_IsOK(res1)) {
15311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15312 }
15313 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15314 {
15315 PyThreadState* __tstate = wxPyBeginAllowThreads();
15316 result = (arg1)->GetPosition();
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15321 return resultobj;
15322 fail:
15323 return NULL;
15324 }
15325
15326
15327 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15328 PyObject *resultobj = 0;
15329 wxJoystick *arg1 = (wxJoystick *) 0 ;
15330 int result;
15331 void *argp1 = 0 ;
15332 int res1 = 0 ;
15333 PyObject *swig_obj[1] ;
15334
15335 if (!args) SWIG_fail;
15336 swig_obj[0] = args;
15337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15338 if (!SWIG_IsOK(res1)) {
15339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15340 }
15341 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15342 {
15343 PyThreadState* __tstate = wxPyBeginAllowThreads();
15344 result = (int)(arg1)->GetZPosition();
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 resultobj = SWIG_From_int(static_cast< int >(result));
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15356 PyObject *resultobj = 0;
15357 wxJoystick *arg1 = (wxJoystick *) 0 ;
15358 int result;
15359 void *argp1 = 0 ;
15360 int res1 = 0 ;
15361 PyObject *swig_obj[1] ;
15362
15363 if (!args) SWIG_fail;
15364 swig_obj[0] = args;
15365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15366 if (!SWIG_IsOK(res1)) {
15367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15368 }
15369 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15370 {
15371 PyThreadState* __tstate = wxPyBeginAllowThreads();
15372 result = (int)(arg1)->GetButtonState();
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 resultobj = SWIG_From_int(static_cast< int >(result));
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxJoystick *arg1 = (wxJoystick *) 0 ;
15386 int result;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15396 }
15397 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 result = (int)(arg1)->GetPOVPosition();
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 resultobj = SWIG_From_int(static_cast< int >(result));
15405 return resultobj;
15406 fail:
15407 return NULL;
15408 }
15409
15410
15411 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15412 PyObject *resultobj = 0;
15413 wxJoystick *arg1 = (wxJoystick *) 0 ;
15414 int result;
15415 void *argp1 = 0 ;
15416 int res1 = 0 ;
15417 PyObject *swig_obj[1] ;
15418
15419 if (!args) SWIG_fail;
15420 swig_obj[0] = args;
15421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15422 if (!SWIG_IsOK(res1)) {
15423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15424 }
15425 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15426 {
15427 PyThreadState* __tstate = wxPyBeginAllowThreads();
15428 result = (int)(arg1)->GetPOVCTSPosition();
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 resultobj = SWIG_From_int(static_cast< int >(result));
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440 PyObject *resultobj = 0;
15441 wxJoystick *arg1 = (wxJoystick *) 0 ;
15442 int result;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 PyObject *swig_obj[1] ;
15446
15447 if (!args) SWIG_fail;
15448 swig_obj[0] = args;
15449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15450 if (!SWIG_IsOK(res1)) {
15451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15452 }
15453 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15454 {
15455 PyThreadState* __tstate = wxPyBeginAllowThreads();
15456 result = (int)(arg1)->GetRudderPosition();
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 resultobj = SWIG_From_int(static_cast< int >(result));
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15468 PyObject *resultobj = 0;
15469 wxJoystick *arg1 = (wxJoystick *) 0 ;
15470 int result;
15471 void *argp1 = 0 ;
15472 int res1 = 0 ;
15473 PyObject *swig_obj[1] ;
15474
15475 if (!args) SWIG_fail;
15476 swig_obj[0] = args;
15477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15478 if (!SWIG_IsOK(res1)) {
15479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15480 }
15481 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (int)(arg1)->GetUPosition();
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 resultobj = SWIG_From_int(static_cast< int >(result));
15489 return resultobj;
15490 fail:
15491 return NULL;
15492 }
15493
15494
15495 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15496 PyObject *resultobj = 0;
15497 wxJoystick *arg1 = (wxJoystick *) 0 ;
15498 int result;
15499 void *argp1 = 0 ;
15500 int res1 = 0 ;
15501 PyObject *swig_obj[1] ;
15502
15503 if (!args) SWIG_fail;
15504 swig_obj[0] = args;
15505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15506 if (!SWIG_IsOK(res1)) {
15507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15508 }
15509 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 result = (int)(arg1)->GetVPosition();
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_From_int(static_cast< int >(result));
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15524 PyObject *resultobj = 0;
15525 wxJoystick *arg1 = (wxJoystick *) 0 ;
15526 int result;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 PyObject *swig_obj[1] ;
15530
15531 if (!args) SWIG_fail;
15532 swig_obj[0] = args;
15533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15536 }
15537 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15538 {
15539 PyThreadState* __tstate = wxPyBeginAllowThreads();
15540 result = (int)(arg1)->GetMovementThreshold();
15541 wxPyEndAllowThreads(__tstate);
15542 if (PyErr_Occurred()) SWIG_fail;
15543 }
15544 resultobj = SWIG_From_int(static_cast< int >(result));
15545 return resultobj;
15546 fail:
15547 return NULL;
15548 }
15549
15550
15551 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15552 PyObject *resultobj = 0;
15553 wxJoystick *arg1 = (wxJoystick *) 0 ;
15554 int arg2 ;
15555 void *argp1 = 0 ;
15556 int res1 = 0 ;
15557 int val2 ;
15558 int ecode2 = 0 ;
15559 PyObject * obj0 = 0 ;
15560 PyObject * obj1 = 0 ;
15561 char * kwnames[] = {
15562 (char *) "self",(char *) "threshold", NULL
15563 };
15564
15565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15567 if (!SWIG_IsOK(res1)) {
15568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15569 }
15570 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15571 ecode2 = SWIG_AsVal_int(obj1, &val2);
15572 if (!SWIG_IsOK(ecode2)) {
15573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15574 }
15575 arg2 = static_cast< int >(val2);
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 (arg1)->SetMovementThreshold(arg2);
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 resultobj = SWIG_Py_Void();
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15590 PyObject *resultobj = 0;
15591 wxJoystick *arg1 = (wxJoystick *) 0 ;
15592 bool result;
15593 void *argp1 = 0 ;
15594 int res1 = 0 ;
15595 PyObject *swig_obj[1] ;
15596
15597 if (!args) SWIG_fail;
15598 swig_obj[0] = args;
15599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15602 }
15603 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15604 {
15605 PyThreadState* __tstate = wxPyBeginAllowThreads();
15606 result = (bool)(arg1)->IsOk();
15607 wxPyEndAllowThreads(__tstate);
15608 if (PyErr_Occurred()) SWIG_fail;
15609 }
15610 {
15611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15612 }
15613 return resultobj;
15614 fail:
15615 return NULL;
15616 }
15617
15618
15619 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15620 PyObject *resultobj = 0;
15621 wxJoystick *arg1 = (wxJoystick *) 0 ;
15622 int result;
15623 void *argp1 = 0 ;
15624 int res1 = 0 ;
15625 PyObject *swig_obj[1] ;
15626
15627 if (!args) SWIG_fail;
15628 swig_obj[0] = args;
15629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15630 if (!SWIG_IsOK(res1)) {
15631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15632 }
15633 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15634 {
15635 PyThreadState* __tstate = wxPyBeginAllowThreads();
15636 result = (int)(arg1)->GetNumberJoysticks();
15637 wxPyEndAllowThreads(__tstate);
15638 if (PyErr_Occurred()) SWIG_fail;
15639 }
15640 resultobj = SWIG_From_int(static_cast< int >(result));
15641 return resultobj;
15642 fail:
15643 return NULL;
15644 }
15645
15646
15647 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15648 PyObject *resultobj = 0;
15649 wxJoystick *arg1 = (wxJoystick *) 0 ;
15650 int result;
15651 void *argp1 = 0 ;
15652 int res1 = 0 ;
15653 PyObject *swig_obj[1] ;
15654
15655 if (!args) SWIG_fail;
15656 swig_obj[0] = args;
15657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15658 if (!SWIG_IsOK(res1)) {
15659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15660 }
15661 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 result = (int)(arg1)->GetManufacturerId();
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 resultobj = SWIG_From_int(static_cast< int >(result));
15669 return resultobj;
15670 fail:
15671 return NULL;
15672 }
15673
15674
15675 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15676 PyObject *resultobj = 0;
15677 wxJoystick *arg1 = (wxJoystick *) 0 ;
15678 int result;
15679 void *argp1 = 0 ;
15680 int res1 = 0 ;
15681 PyObject *swig_obj[1] ;
15682
15683 if (!args) SWIG_fail;
15684 swig_obj[0] = args;
15685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15686 if (!SWIG_IsOK(res1)) {
15687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15688 }
15689 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15690 {
15691 PyThreadState* __tstate = wxPyBeginAllowThreads();
15692 result = (int)(arg1)->GetProductId();
15693 wxPyEndAllowThreads(__tstate);
15694 if (PyErr_Occurred()) SWIG_fail;
15695 }
15696 resultobj = SWIG_From_int(static_cast< int >(result));
15697 return resultobj;
15698 fail:
15699 return NULL;
15700 }
15701
15702
15703 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15704 PyObject *resultobj = 0;
15705 wxJoystick *arg1 = (wxJoystick *) 0 ;
15706 wxString result;
15707 void *argp1 = 0 ;
15708 int res1 = 0 ;
15709 PyObject *swig_obj[1] ;
15710
15711 if (!args) SWIG_fail;
15712 swig_obj[0] = args;
15713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15714 if (!SWIG_IsOK(res1)) {
15715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15716 }
15717 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15718 {
15719 PyThreadState* __tstate = wxPyBeginAllowThreads();
15720 result = (arg1)->GetProductName();
15721 wxPyEndAllowThreads(__tstate);
15722 if (PyErr_Occurred()) SWIG_fail;
15723 }
15724 {
15725 #if wxUSE_UNICODE
15726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15727 #else
15728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15729 #endif
15730 }
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxJoystick *arg1 = (wxJoystick *) 0 ;
15740 int result;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 PyObject *swig_obj[1] ;
15744
15745 if (!args) SWIG_fail;
15746 swig_obj[0] = args;
15747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15750 }
15751 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (int)(arg1)->GetXMin();
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_From_int(static_cast< int >(result));
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxJoystick *arg1 = (wxJoystick *) 0 ;
15768 int result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15778 }
15779 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = (int)(arg1)->GetYMin();
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_From_int(static_cast< int >(result));
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15794 PyObject *resultobj = 0;
15795 wxJoystick *arg1 = (wxJoystick *) 0 ;
15796 int result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 PyObject *swig_obj[1] ;
15800
15801 if (!args) SWIG_fail;
15802 swig_obj[0] = args;
15803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15804 if (!SWIG_IsOK(res1)) {
15805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15806 }
15807 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15808 {
15809 PyThreadState* __tstate = wxPyBeginAllowThreads();
15810 result = (int)(arg1)->GetZMin();
15811 wxPyEndAllowThreads(__tstate);
15812 if (PyErr_Occurred()) SWIG_fail;
15813 }
15814 resultobj = SWIG_From_int(static_cast< int >(result));
15815 return resultobj;
15816 fail:
15817 return NULL;
15818 }
15819
15820
15821 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15822 PyObject *resultobj = 0;
15823 wxJoystick *arg1 = (wxJoystick *) 0 ;
15824 int result;
15825 void *argp1 = 0 ;
15826 int res1 = 0 ;
15827 PyObject *swig_obj[1] ;
15828
15829 if (!args) SWIG_fail;
15830 swig_obj[0] = args;
15831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15832 if (!SWIG_IsOK(res1)) {
15833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15834 }
15835 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15836 {
15837 PyThreadState* __tstate = wxPyBeginAllowThreads();
15838 result = (int)(arg1)->GetXMax();
15839 wxPyEndAllowThreads(__tstate);
15840 if (PyErr_Occurred()) SWIG_fail;
15841 }
15842 resultobj = SWIG_From_int(static_cast< int >(result));
15843 return resultobj;
15844 fail:
15845 return NULL;
15846 }
15847
15848
15849 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15850 PyObject *resultobj = 0;
15851 wxJoystick *arg1 = (wxJoystick *) 0 ;
15852 int result;
15853 void *argp1 = 0 ;
15854 int res1 = 0 ;
15855 PyObject *swig_obj[1] ;
15856
15857 if (!args) SWIG_fail;
15858 swig_obj[0] = args;
15859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15860 if (!SWIG_IsOK(res1)) {
15861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15862 }
15863 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15864 {
15865 PyThreadState* __tstate = wxPyBeginAllowThreads();
15866 result = (int)(arg1)->GetYMax();
15867 wxPyEndAllowThreads(__tstate);
15868 if (PyErr_Occurred()) SWIG_fail;
15869 }
15870 resultobj = SWIG_From_int(static_cast< int >(result));
15871 return resultobj;
15872 fail:
15873 return NULL;
15874 }
15875
15876
15877 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15878 PyObject *resultobj = 0;
15879 wxJoystick *arg1 = (wxJoystick *) 0 ;
15880 int result;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 PyObject *swig_obj[1] ;
15884
15885 if (!args) SWIG_fail;
15886 swig_obj[0] = args;
15887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15890 }
15891 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15892 {
15893 PyThreadState* __tstate = wxPyBeginAllowThreads();
15894 result = (int)(arg1)->GetZMax();
15895 wxPyEndAllowThreads(__tstate);
15896 if (PyErr_Occurred()) SWIG_fail;
15897 }
15898 resultobj = SWIG_From_int(static_cast< int >(result));
15899 return resultobj;
15900 fail:
15901 return NULL;
15902 }
15903
15904
15905 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15906 PyObject *resultobj = 0;
15907 wxJoystick *arg1 = (wxJoystick *) 0 ;
15908 int result;
15909 void *argp1 = 0 ;
15910 int res1 = 0 ;
15911 PyObject *swig_obj[1] ;
15912
15913 if (!args) SWIG_fail;
15914 swig_obj[0] = args;
15915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15916 if (!SWIG_IsOK(res1)) {
15917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15918 }
15919 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15920 {
15921 PyThreadState* __tstate = wxPyBeginAllowThreads();
15922 result = (int)(arg1)->GetNumberButtons();
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 resultobj = SWIG_From_int(static_cast< int >(result));
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15934 PyObject *resultobj = 0;
15935 wxJoystick *arg1 = (wxJoystick *) 0 ;
15936 int result;
15937 void *argp1 = 0 ;
15938 int res1 = 0 ;
15939 PyObject *swig_obj[1] ;
15940
15941 if (!args) SWIG_fail;
15942 swig_obj[0] = args;
15943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15946 }
15947 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15948 {
15949 PyThreadState* __tstate = wxPyBeginAllowThreads();
15950 result = (int)(arg1)->GetNumberAxes();
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_From_int(static_cast< int >(result));
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15962 PyObject *resultobj = 0;
15963 wxJoystick *arg1 = (wxJoystick *) 0 ;
15964 int result;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 PyObject *swig_obj[1] ;
15968
15969 if (!args) SWIG_fail;
15970 swig_obj[0] = args;
15971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15974 }
15975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15976 {
15977 PyThreadState* __tstate = wxPyBeginAllowThreads();
15978 result = (int)(arg1)->GetMaxButtons();
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 resultobj = SWIG_From_int(static_cast< int >(result));
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15990 PyObject *resultobj = 0;
15991 wxJoystick *arg1 = (wxJoystick *) 0 ;
15992 int result;
15993 void *argp1 = 0 ;
15994 int res1 = 0 ;
15995 PyObject *swig_obj[1] ;
15996
15997 if (!args) SWIG_fail;
15998 swig_obj[0] = args;
15999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16000 if (!SWIG_IsOK(res1)) {
16001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
16002 }
16003 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16004 {
16005 PyThreadState* __tstate = wxPyBeginAllowThreads();
16006 result = (int)(arg1)->GetMaxAxes();
16007 wxPyEndAllowThreads(__tstate);
16008 if (PyErr_Occurred()) SWIG_fail;
16009 }
16010 resultobj = SWIG_From_int(static_cast< int >(result));
16011 return resultobj;
16012 fail:
16013 return NULL;
16014 }
16015
16016
16017 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16018 PyObject *resultobj = 0;
16019 wxJoystick *arg1 = (wxJoystick *) 0 ;
16020 int result;
16021 void *argp1 = 0 ;
16022 int res1 = 0 ;
16023 PyObject *swig_obj[1] ;
16024
16025 if (!args) SWIG_fail;
16026 swig_obj[0] = args;
16027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16028 if (!SWIG_IsOK(res1)) {
16029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16030 }
16031 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 result = (int)(arg1)->GetPollingMin();
16035 wxPyEndAllowThreads(__tstate);
16036 if (PyErr_Occurred()) SWIG_fail;
16037 }
16038 resultobj = SWIG_From_int(static_cast< int >(result));
16039 return resultobj;
16040 fail:
16041 return NULL;
16042 }
16043
16044
16045 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16046 PyObject *resultobj = 0;
16047 wxJoystick *arg1 = (wxJoystick *) 0 ;
16048 int result;
16049 void *argp1 = 0 ;
16050 int res1 = 0 ;
16051 PyObject *swig_obj[1] ;
16052
16053 if (!args) SWIG_fail;
16054 swig_obj[0] = args;
16055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16056 if (!SWIG_IsOK(res1)) {
16057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16058 }
16059 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16060 {
16061 PyThreadState* __tstate = wxPyBeginAllowThreads();
16062 result = (int)(arg1)->GetPollingMax();
16063 wxPyEndAllowThreads(__tstate);
16064 if (PyErr_Occurred()) SWIG_fail;
16065 }
16066 resultobj = SWIG_From_int(static_cast< int >(result));
16067 return resultobj;
16068 fail:
16069 return NULL;
16070 }
16071
16072
16073 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16074 PyObject *resultobj = 0;
16075 wxJoystick *arg1 = (wxJoystick *) 0 ;
16076 int result;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 PyObject *swig_obj[1] ;
16080
16081 if (!args) SWIG_fail;
16082 swig_obj[0] = args;
16083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16084 if (!SWIG_IsOK(res1)) {
16085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16086 }
16087 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16088 {
16089 PyThreadState* __tstate = wxPyBeginAllowThreads();
16090 result = (int)(arg1)->GetRudderMin();
16091 wxPyEndAllowThreads(__tstate);
16092 if (PyErr_Occurred()) SWIG_fail;
16093 }
16094 resultobj = SWIG_From_int(static_cast< int >(result));
16095 return resultobj;
16096 fail:
16097 return NULL;
16098 }
16099
16100
16101 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16102 PyObject *resultobj = 0;
16103 wxJoystick *arg1 = (wxJoystick *) 0 ;
16104 int result;
16105 void *argp1 = 0 ;
16106 int res1 = 0 ;
16107 PyObject *swig_obj[1] ;
16108
16109 if (!args) SWIG_fail;
16110 swig_obj[0] = args;
16111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16112 if (!SWIG_IsOK(res1)) {
16113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16114 }
16115 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16116 {
16117 PyThreadState* __tstate = wxPyBeginAllowThreads();
16118 result = (int)(arg1)->GetRudderMax();
16119 wxPyEndAllowThreads(__tstate);
16120 if (PyErr_Occurred()) SWIG_fail;
16121 }
16122 resultobj = SWIG_From_int(static_cast< int >(result));
16123 return resultobj;
16124 fail:
16125 return NULL;
16126 }
16127
16128
16129 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16130 PyObject *resultobj = 0;
16131 wxJoystick *arg1 = (wxJoystick *) 0 ;
16132 int result;
16133 void *argp1 = 0 ;
16134 int res1 = 0 ;
16135 PyObject *swig_obj[1] ;
16136
16137 if (!args) SWIG_fail;
16138 swig_obj[0] = args;
16139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16140 if (!SWIG_IsOK(res1)) {
16141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16142 }
16143 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 result = (int)(arg1)->GetUMin();
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 resultobj = SWIG_From_int(static_cast< int >(result));
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16158 PyObject *resultobj = 0;
16159 wxJoystick *arg1 = (wxJoystick *) 0 ;
16160 int result;
16161 void *argp1 = 0 ;
16162 int res1 = 0 ;
16163 PyObject *swig_obj[1] ;
16164
16165 if (!args) SWIG_fail;
16166 swig_obj[0] = args;
16167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16168 if (!SWIG_IsOK(res1)) {
16169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16170 }
16171 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16172 {
16173 PyThreadState* __tstate = wxPyBeginAllowThreads();
16174 result = (int)(arg1)->GetUMax();
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 resultobj = SWIG_From_int(static_cast< int >(result));
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16186 PyObject *resultobj = 0;
16187 wxJoystick *arg1 = (wxJoystick *) 0 ;
16188 int result;
16189 void *argp1 = 0 ;
16190 int res1 = 0 ;
16191 PyObject *swig_obj[1] ;
16192
16193 if (!args) SWIG_fail;
16194 swig_obj[0] = args;
16195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16196 if (!SWIG_IsOK(res1)) {
16197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16198 }
16199 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16200 {
16201 PyThreadState* __tstate = wxPyBeginAllowThreads();
16202 result = (int)(arg1)->GetVMin();
16203 wxPyEndAllowThreads(__tstate);
16204 if (PyErr_Occurred()) SWIG_fail;
16205 }
16206 resultobj = SWIG_From_int(static_cast< int >(result));
16207 return resultobj;
16208 fail:
16209 return NULL;
16210 }
16211
16212
16213 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16214 PyObject *resultobj = 0;
16215 wxJoystick *arg1 = (wxJoystick *) 0 ;
16216 int result;
16217 void *argp1 = 0 ;
16218 int res1 = 0 ;
16219 PyObject *swig_obj[1] ;
16220
16221 if (!args) SWIG_fail;
16222 swig_obj[0] = args;
16223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16226 }
16227 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16228 {
16229 PyThreadState* __tstate = wxPyBeginAllowThreads();
16230 result = (int)(arg1)->GetVMax();
16231 wxPyEndAllowThreads(__tstate);
16232 if (PyErr_Occurred()) SWIG_fail;
16233 }
16234 resultobj = SWIG_From_int(static_cast< int >(result));
16235 return resultobj;
16236 fail:
16237 return NULL;
16238 }
16239
16240
16241 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16242 PyObject *resultobj = 0;
16243 wxJoystick *arg1 = (wxJoystick *) 0 ;
16244 bool result;
16245 void *argp1 = 0 ;
16246 int res1 = 0 ;
16247 PyObject *swig_obj[1] ;
16248
16249 if (!args) SWIG_fail;
16250 swig_obj[0] = args;
16251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16252 if (!SWIG_IsOK(res1)) {
16253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16254 }
16255 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16256 {
16257 PyThreadState* __tstate = wxPyBeginAllowThreads();
16258 result = (bool)(arg1)->HasRudder();
16259 wxPyEndAllowThreads(__tstate);
16260 if (PyErr_Occurred()) SWIG_fail;
16261 }
16262 {
16263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16264 }
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16272 PyObject *resultobj = 0;
16273 wxJoystick *arg1 = (wxJoystick *) 0 ;
16274 bool result;
16275 void *argp1 = 0 ;
16276 int res1 = 0 ;
16277 PyObject *swig_obj[1] ;
16278
16279 if (!args) SWIG_fail;
16280 swig_obj[0] = args;
16281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16282 if (!SWIG_IsOK(res1)) {
16283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16284 }
16285 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16286 {
16287 PyThreadState* __tstate = wxPyBeginAllowThreads();
16288 result = (bool)(arg1)->HasZ();
16289 wxPyEndAllowThreads(__tstate);
16290 if (PyErr_Occurred()) SWIG_fail;
16291 }
16292 {
16293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16294 }
16295 return resultobj;
16296 fail:
16297 return NULL;
16298 }
16299
16300
16301 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16302 PyObject *resultobj = 0;
16303 wxJoystick *arg1 = (wxJoystick *) 0 ;
16304 bool result;
16305 void *argp1 = 0 ;
16306 int res1 = 0 ;
16307 PyObject *swig_obj[1] ;
16308
16309 if (!args) SWIG_fail;
16310 swig_obj[0] = args;
16311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16312 if (!SWIG_IsOK(res1)) {
16313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16314 }
16315 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16316 {
16317 PyThreadState* __tstate = wxPyBeginAllowThreads();
16318 result = (bool)(arg1)->HasU();
16319 wxPyEndAllowThreads(__tstate);
16320 if (PyErr_Occurred()) SWIG_fail;
16321 }
16322 {
16323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16324 }
16325 return resultobj;
16326 fail:
16327 return NULL;
16328 }
16329
16330
16331 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16332 PyObject *resultobj = 0;
16333 wxJoystick *arg1 = (wxJoystick *) 0 ;
16334 bool result;
16335 void *argp1 = 0 ;
16336 int res1 = 0 ;
16337 PyObject *swig_obj[1] ;
16338
16339 if (!args) SWIG_fail;
16340 swig_obj[0] = args;
16341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16342 if (!SWIG_IsOK(res1)) {
16343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16344 }
16345 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16346 {
16347 PyThreadState* __tstate = wxPyBeginAllowThreads();
16348 result = (bool)(arg1)->HasV();
16349 wxPyEndAllowThreads(__tstate);
16350 if (PyErr_Occurred()) SWIG_fail;
16351 }
16352 {
16353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16354 }
16355 return resultobj;
16356 fail:
16357 return NULL;
16358 }
16359
16360
16361 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16362 PyObject *resultobj = 0;
16363 wxJoystick *arg1 = (wxJoystick *) 0 ;
16364 bool result;
16365 void *argp1 = 0 ;
16366 int res1 = 0 ;
16367 PyObject *swig_obj[1] ;
16368
16369 if (!args) SWIG_fail;
16370 swig_obj[0] = args;
16371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16372 if (!SWIG_IsOK(res1)) {
16373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16374 }
16375 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16376 {
16377 PyThreadState* __tstate = wxPyBeginAllowThreads();
16378 result = (bool)(arg1)->HasPOV();
16379 wxPyEndAllowThreads(__tstate);
16380 if (PyErr_Occurred()) SWIG_fail;
16381 }
16382 {
16383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16384 }
16385 return resultobj;
16386 fail:
16387 return NULL;
16388 }
16389
16390
16391 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16392 PyObject *resultobj = 0;
16393 wxJoystick *arg1 = (wxJoystick *) 0 ;
16394 bool result;
16395 void *argp1 = 0 ;
16396 int res1 = 0 ;
16397 PyObject *swig_obj[1] ;
16398
16399 if (!args) SWIG_fail;
16400 swig_obj[0] = args;
16401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16404 }
16405 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16406 {
16407 PyThreadState* __tstate = wxPyBeginAllowThreads();
16408 result = (bool)(arg1)->HasPOV4Dir();
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 {
16413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16414 }
16415 return resultobj;
16416 fail:
16417 return NULL;
16418 }
16419
16420
16421 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16422 PyObject *resultobj = 0;
16423 wxJoystick *arg1 = (wxJoystick *) 0 ;
16424 bool result;
16425 void *argp1 = 0 ;
16426 int res1 = 0 ;
16427 PyObject *swig_obj[1] ;
16428
16429 if (!args) SWIG_fail;
16430 swig_obj[0] = args;
16431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16432 if (!SWIG_IsOK(res1)) {
16433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16434 }
16435 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16436 {
16437 PyThreadState* __tstate = wxPyBeginAllowThreads();
16438 result = (bool)(arg1)->HasPOVCTS();
16439 wxPyEndAllowThreads(__tstate);
16440 if (PyErr_Occurred()) SWIG_fail;
16441 }
16442 {
16443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16444 }
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj = 0;
16453 wxJoystick *arg1 = (wxJoystick *) 0 ;
16454 wxWindow *arg2 = (wxWindow *) 0 ;
16455 int arg3 = (int) 0 ;
16456 bool result;
16457 void *argp1 = 0 ;
16458 int res1 = 0 ;
16459 void *argp2 = 0 ;
16460 int res2 = 0 ;
16461 int val3 ;
16462 int ecode3 = 0 ;
16463 PyObject * obj0 = 0 ;
16464 PyObject * obj1 = 0 ;
16465 PyObject * obj2 = 0 ;
16466 char * kwnames[] = {
16467 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16468 };
16469
16470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16472 if (!SWIG_IsOK(res1)) {
16473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16474 }
16475 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16477 if (!SWIG_IsOK(res2)) {
16478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16479 }
16480 arg2 = reinterpret_cast< wxWindow * >(argp2);
16481 if (obj2) {
16482 ecode3 = SWIG_AsVal_int(obj2, &val3);
16483 if (!SWIG_IsOK(ecode3)) {
16484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16485 }
16486 arg3 = static_cast< int >(val3);
16487 }
16488 {
16489 PyThreadState* __tstate = wxPyBeginAllowThreads();
16490 result = (bool)(arg1)->SetCapture(arg2,arg3);
16491 wxPyEndAllowThreads(__tstate);
16492 if (PyErr_Occurred()) SWIG_fail;
16493 }
16494 {
16495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16496 }
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16504 PyObject *resultobj = 0;
16505 wxJoystick *arg1 = (wxJoystick *) 0 ;
16506 bool result;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 PyObject *swig_obj[1] ;
16510
16511 if (!args) SWIG_fail;
16512 swig_obj[0] = args;
16513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16514 if (!SWIG_IsOK(res1)) {
16515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16516 }
16517 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16518 {
16519 PyThreadState* __tstate = wxPyBeginAllowThreads();
16520 result = (bool)(arg1)->ReleaseCapture();
16521 wxPyEndAllowThreads(__tstate);
16522 if (PyErr_Occurred()) SWIG_fail;
16523 }
16524 {
16525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16526 }
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16534 PyObject *obj;
16535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16536 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16537 return SWIG_Py_Void();
16538 }
16539
16540 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16541 return SWIG_Python_InitShadowInstance(args);
16542 }
16543
16544 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16545 PyObject *resultobj = 0;
16546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16547 int arg2 = (int) 0 ;
16548 int arg3 = (int) wxJOYSTICK1 ;
16549 int arg4 = (int) 0 ;
16550 wxJoystickEvent *result = 0 ;
16551 int val1 ;
16552 int ecode1 = 0 ;
16553 int val2 ;
16554 int ecode2 = 0 ;
16555 int val3 ;
16556 int ecode3 = 0 ;
16557 int val4 ;
16558 int ecode4 = 0 ;
16559 PyObject * obj0 = 0 ;
16560 PyObject * obj1 = 0 ;
16561 PyObject * obj2 = 0 ;
16562 PyObject * obj3 = 0 ;
16563 char * kwnames[] = {
16564 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16565 };
16566
16567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16568 if (obj0) {
16569 ecode1 = SWIG_AsVal_int(obj0, &val1);
16570 if (!SWIG_IsOK(ecode1)) {
16571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16572 }
16573 arg1 = static_cast< wxEventType >(val1);
16574 }
16575 if (obj1) {
16576 ecode2 = SWIG_AsVal_int(obj1, &val2);
16577 if (!SWIG_IsOK(ecode2)) {
16578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16579 }
16580 arg2 = static_cast< int >(val2);
16581 }
16582 if (obj2) {
16583 ecode3 = SWIG_AsVal_int(obj2, &val3);
16584 if (!SWIG_IsOK(ecode3)) {
16585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16586 }
16587 arg3 = static_cast< int >(val3);
16588 }
16589 if (obj3) {
16590 ecode4 = SWIG_AsVal_int(obj3, &val4);
16591 if (!SWIG_IsOK(ecode4)) {
16592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16593 }
16594 arg4 = static_cast< int >(val4);
16595 }
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16610 PyObject *resultobj = 0;
16611 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16612 wxPoint result;
16613 void *argp1 = 0 ;
16614 int res1 = 0 ;
16615 PyObject *swig_obj[1] ;
16616
16617 if (!args) SWIG_fail;
16618 swig_obj[0] = args;
16619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16620 if (!SWIG_IsOK(res1)) {
16621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16622 }
16623 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16638 PyObject *resultobj = 0;
16639 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16640 int result;
16641 void *argp1 = 0 ;
16642 int res1 = 0 ;
16643 PyObject *swig_obj[1] ;
16644
16645 if (!args) SWIG_fail;
16646 swig_obj[0] = args;
16647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16648 if (!SWIG_IsOK(res1)) {
16649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16650 }
16651 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16652 {
16653 PyThreadState* __tstate = wxPyBeginAllowThreads();
16654 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16655 wxPyEndAllowThreads(__tstate);
16656 if (PyErr_Occurred()) SWIG_fail;
16657 }
16658 resultobj = SWIG_From_int(static_cast< int >(result));
16659 return resultobj;
16660 fail:
16661 return NULL;
16662 }
16663
16664
16665 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16666 PyObject *resultobj = 0;
16667 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16668 int result;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 PyObject *swig_obj[1] ;
16672
16673 if (!args) SWIG_fail;
16674 swig_obj[0] = args;
16675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16676 if (!SWIG_IsOK(res1)) {
16677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16678 }
16679 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_From_int(static_cast< int >(result));
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16694 PyObject *resultobj = 0;
16695 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16696 int result;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 PyObject *swig_obj[1] ;
16700
16701 if (!args) SWIG_fail;
16702 swig_obj[0] = args;
16703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16704 if (!SWIG_IsOK(res1)) {
16705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16706 }
16707 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16708 {
16709 PyThreadState* __tstate = wxPyBeginAllowThreads();
16710 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16711 wxPyEndAllowThreads(__tstate);
16712 if (PyErr_Occurred()) SWIG_fail;
16713 }
16714 resultobj = SWIG_From_int(static_cast< int >(result));
16715 return resultobj;
16716 fail:
16717 return NULL;
16718 }
16719
16720
16721 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16722 PyObject *resultobj = 0;
16723 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16724 int result;
16725 void *argp1 = 0 ;
16726 int res1 = 0 ;
16727 PyObject *swig_obj[1] ;
16728
16729 if (!args) SWIG_fail;
16730 swig_obj[0] = args;
16731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16732 if (!SWIG_IsOK(res1)) {
16733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16734 }
16735 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16736 {
16737 PyThreadState* __tstate = wxPyBeginAllowThreads();
16738 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16739 wxPyEndAllowThreads(__tstate);
16740 if (PyErr_Occurred()) SWIG_fail;
16741 }
16742 resultobj = SWIG_From_int(static_cast< int >(result));
16743 return resultobj;
16744 fail:
16745 return NULL;
16746 }
16747
16748
16749 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj = 0;
16751 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16752 int arg2 ;
16753 void *argp1 = 0 ;
16754 int res1 = 0 ;
16755 int val2 ;
16756 int ecode2 = 0 ;
16757 PyObject * obj0 = 0 ;
16758 PyObject * obj1 = 0 ;
16759 char * kwnames[] = {
16760 (char *) "self",(char *) "stick", NULL
16761 };
16762
16763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16765 if (!SWIG_IsOK(res1)) {
16766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16767 }
16768 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16769 ecode2 = SWIG_AsVal_int(obj1, &val2);
16770 if (!SWIG_IsOK(ecode2)) {
16771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16772 }
16773 arg2 = static_cast< int >(val2);
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 (arg1)->SetJoystick(arg2);
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 resultobj = SWIG_Py_Void();
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj = 0;
16789 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16790 int arg2 ;
16791 void *argp1 = 0 ;
16792 int res1 = 0 ;
16793 int val2 ;
16794 int ecode2 = 0 ;
16795 PyObject * obj0 = 0 ;
16796 PyObject * obj1 = 0 ;
16797 char * kwnames[] = {
16798 (char *) "self",(char *) "state", NULL
16799 };
16800
16801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16803 if (!SWIG_IsOK(res1)) {
16804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16805 }
16806 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16807 ecode2 = SWIG_AsVal_int(obj1, &val2);
16808 if (!SWIG_IsOK(ecode2)) {
16809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16810 }
16811 arg2 = static_cast< int >(val2);
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 (arg1)->SetButtonState(arg2);
16815 wxPyEndAllowThreads(__tstate);
16816 if (PyErr_Occurred()) SWIG_fail;
16817 }
16818 resultobj = SWIG_Py_Void();
16819 return resultobj;
16820 fail:
16821 return NULL;
16822 }
16823
16824
16825 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16826 PyObject *resultobj = 0;
16827 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16828 int arg2 ;
16829 void *argp1 = 0 ;
16830 int res1 = 0 ;
16831 int val2 ;
16832 int ecode2 = 0 ;
16833 PyObject * obj0 = 0 ;
16834 PyObject * obj1 = 0 ;
16835 char * kwnames[] = {
16836 (char *) "self",(char *) "change", NULL
16837 };
16838
16839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16841 if (!SWIG_IsOK(res1)) {
16842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16843 }
16844 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16845 ecode2 = SWIG_AsVal_int(obj1, &val2);
16846 if (!SWIG_IsOK(ecode2)) {
16847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16848 }
16849 arg2 = static_cast< int >(val2);
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 (arg1)->SetButtonChange(arg2);
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 resultobj = SWIG_Py_Void();
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16864 PyObject *resultobj = 0;
16865 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16866 wxPoint *arg2 = 0 ;
16867 void *argp1 = 0 ;
16868 int res1 = 0 ;
16869 wxPoint temp2 ;
16870 PyObject * obj0 = 0 ;
16871 PyObject * obj1 = 0 ;
16872 char * kwnames[] = {
16873 (char *) "self",(char *) "pos", NULL
16874 };
16875
16876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16878 if (!SWIG_IsOK(res1)) {
16879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16880 }
16881 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16882 {
16883 arg2 = &temp2;
16884 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16885 }
16886 {
16887 PyThreadState* __tstate = wxPyBeginAllowThreads();
16888 (arg1)->SetPosition((wxPoint const &)*arg2);
16889 wxPyEndAllowThreads(__tstate);
16890 if (PyErr_Occurred()) SWIG_fail;
16891 }
16892 resultobj = SWIG_Py_Void();
16893 return resultobj;
16894 fail:
16895 return NULL;
16896 }
16897
16898
16899 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16900 PyObject *resultobj = 0;
16901 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16902 int arg2 ;
16903 void *argp1 = 0 ;
16904 int res1 = 0 ;
16905 int val2 ;
16906 int ecode2 = 0 ;
16907 PyObject * obj0 = 0 ;
16908 PyObject * obj1 = 0 ;
16909 char * kwnames[] = {
16910 (char *) "self",(char *) "zPos", NULL
16911 };
16912
16913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16915 if (!SWIG_IsOK(res1)) {
16916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16917 }
16918 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16919 ecode2 = SWIG_AsVal_int(obj1, &val2);
16920 if (!SWIG_IsOK(ecode2)) {
16921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16922 }
16923 arg2 = static_cast< int >(val2);
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 (arg1)->SetZPosition(arg2);
16927 wxPyEndAllowThreads(__tstate);
16928 if (PyErr_Occurred()) SWIG_fail;
16929 }
16930 resultobj = SWIG_Py_Void();
16931 return resultobj;
16932 fail:
16933 return NULL;
16934 }
16935
16936
16937 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16938 PyObject *resultobj = 0;
16939 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16940 bool result;
16941 void *argp1 = 0 ;
16942 int res1 = 0 ;
16943 PyObject *swig_obj[1] ;
16944
16945 if (!args) SWIG_fail;
16946 swig_obj[0] = args;
16947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16948 if (!SWIG_IsOK(res1)) {
16949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16950 }
16951 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 {
16959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16960 }
16961 return resultobj;
16962 fail:
16963 return NULL;
16964 }
16965
16966
16967 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16968 PyObject *resultobj = 0;
16969 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16970 bool result;
16971 void *argp1 = 0 ;
16972 int res1 = 0 ;
16973 PyObject *swig_obj[1] ;
16974
16975 if (!args) SWIG_fail;
16976 swig_obj[0] = args;
16977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16978 if (!SWIG_IsOK(res1)) {
16979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16980 }
16981 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16982 {
16983 PyThreadState* __tstate = wxPyBeginAllowThreads();
16984 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16985 wxPyEndAllowThreads(__tstate);
16986 if (PyErr_Occurred()) SWIG_fail;
16987 }
16988 {
16989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16990 }
16991 return resultobj;
16992 fail:
16993 return NULL;
16994 }
16995
16996
16997 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16998 PyObject *resultobj = 0;
16999 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17000 bool result;
17001 void *argp1 = 0 ;
17002 int res1 = 0 ;
17003 PyObject *swig_obj[1] ;
17004
17005 if (!args) SWIG_fail;
17006 swig_obj[0] = args;
17007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17008 if (!SWIG_IsOK(res1)) {
17009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17010 }
17011 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
17015 wxPyEndAllowThreads(__tstate);
17016 if (PyErr_Occurred()) SWIG_fail;
17017 }
17018 {
17019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17020 }
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj = 0;
17029 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17030 int arg2 = (int) wxJOY_BUTTON_ANY ;
17031 bool result;
17032 void *argp1 = 0 ;
17033 int res1 = 0 ;
17034 int val2 ;
17035 int ecode2 = 0 ;
17036 PyObject * obj0 = 0 ;
17037 PyObject * obj1 = 0 ;
17038 char * kwnames[] = {
17039 (char *) "self",(char *) "but", NULL
17040 };
17041
17042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17044 if (!SWIG_IsOK(res1)) {
17045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17046 }
17047 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17048 if (obj1) {
17049 ecode2 = SWIG_AsVal_int(obj1, &val2);
17050 if (!SWIG_IsOK(ecode2)) {
17051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17052 }
17053 arg2 = static_cast< int >(val2);
17054 }
17055 {
17056 PyThreadState* __tstate = wxPyBeginAllowThreads();
17057 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 {
17062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17063 }
17064 return resultobj;
17065 fail:
17066 return NULL;
17067 }
17068
17069
17070 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17071 PyObject *resultobj = 0;
17072 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17073 int arg2 = (int) wxJOY_BUTTON_ANY ;
17074 bool result;
17075 void *argp1 = 0 ;
17076 int res1 = 0 ;
17077 int val2 ;
17078 int ecode2 = 0 ;
17079 PyObject * obj0 = 0 ;
17080 PyObject * obj1 = 0 ;
17081 char * kwnames[] = {
17082 (char *) "self",(char *) "but", NULL
17083 };
17084
17085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17087 if (!SWIG_IsOK(res1)) {
17088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17089 }
17090 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17091 if (obj1) {
17092 ecode2 = SWIG_AsVal_int(obj1, &val2);
17093 if (!SWIG_IsOK(ecode2)) {
17094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17095 }
17096 arg2 = static_cast< int >(val2);
17097 }
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17101 wxPyEndAllowThreads(__tstate);
17102 if (PyErr_Occurred()) SWIG_fail;
17103 }
17104 {
17105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17106 }
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj = 0;
17115 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17116 int arg2 = (int) wxJOY_BUTTON_ANY ;
17117 bool result;
17118 void *argp1 = 0 ;
17119 int res1 = 0 ;
17120 int val2 ;
17121 int ecode2 = 0 ;
17122 PyObject * obj0 = 0 ;
17123 PyObject * obj1 = 0 ;
17124 char * kwnames[] = {
17125 (char *) "self",(char *) "but", NULL
17126 };
17127
17128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17130 if (!SWIG_IsOK(res1)) {
17131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17132 }
17133 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17134 if (obj1) {
17135 ecode2 = SWIG_AsVal_int(obj1, &val2);
17136 if (!SWIG_IsOK(ecode2)) {
17137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17138 }
17139 arg2 = static_cast< int >(val2);
17140 }
17141 {
17142 PyThreadState* __tstate = wxPyBeginAllowThreads();
17143 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 {
17148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17149 }
17150 return resultobj;
17151 fail:
17152 return NULL;
17153 }
17154
17155
17156 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17157 PyObject *obj;
17158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17159 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17160 return SWIG_Py_Void();
17161 }
17162
17163 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17164 return SWIG_Python_InitShadowInstance(args);
17165 }
17166
17167 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17168 PyObject *resultobj = 0;
17169 wxString const &arg1_defvalue = wxPyEmptyString ;
17170 wxString *arg1 = (wxString *) &arg1_defvalue ;
17171 wxSound *result = 0 ;
17172 bool temp1 = false ;
17173 PyObject * obj0 = 0 ;
17174 char * kwnames[] = {
17175 (char *) "fileName", NULL
17176 };
17177
17178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17179 if (obj0) {
17180 {
17181 arg1 = wxString_in_helper(obj0);
17182 if (arg1 == NULL) SWIG_fail;
17183 temp1 = true;
17184 }
17185 }
17186 {
17187 if (!wxPyCheckForApp()) SWIG_fail;
17188 PyThreadState* __tstate = wxPyBeginAllowThreads();
17189 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17190 wxPyEndAllowThreads(__tstate);
17191 if (PyErr_Occurred()) SWIG_fail;
17192 }
17193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17194 {
17195 if (temp1)
17196 delete arg1;
17197 }
17198 return resultobj;
17199 fail:
17200 {
17201 if (temp1)
17202 delete arg1;
17203 }
17204 return NULL;
17205 }
17206
17207
17208 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17209 PyObject *resultobj = 0;
17210 PyObject *arg1 = (PyObject *) 0 ;
17211 wxSound *result = 0 ;
17212 PyObject * obj0 = 0 ;
17213 char * kwnames[] = {
17214 (char *) "data", NULL
17215 };
17216
17217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17218 arg1 = obj0;
17219 {
17220 if (!wxPyCheckForApp()) SWIG_fail;
17221 PyThreadState* __tstate = wxPyBeginAllowThreads();
17222 result = (wxSound *)new_wxSound(arg1);
17223 wxPyEndAllowThreads(__tstate);
17224 if (PyErr_Occurred()) SWIG_fail;
17225 }
17226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17234 PyObject *resultobj = 0;
17235 wxSound *arg1 = (wxSound *) 0 ;
17236 void *argp1 = 0 ;
17237 int res1 = 0 ;
17238 PyObject *swig_obj[1] ;
17239
17240 if (!args) SWIG_fail;
17241 swig_obj[0] = args;
17242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17243 if (!SWIG_IsOK(res1)) {
17244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17245 }
17246 arg1 = reinterpret_cast< wxSound * >(argp1);
17247 {
17248 PyThreadState* __tstate = wxPyBeginAllowThreads();
17249 delete arg1;
17250
17251 wxPyEndAllowThreads(__tstate);
17252 if (PyErr_Occurred()) SWIG_fail;
17253 }
17254 resultobj = SWIG_Py_Void();
17255 return resultobj;
17256 fail:
17257 return NULL;
17258 }
17259
17260
17261 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj = 0;
17263 wxSound *arg1 = (wxSound *) 0 ;
17264 wxString *arg2 = 0 ;
17265 bool result;
17266 void *argp1 = 0 ;
17267 int res1 = 0 ;
17268 bool temp2 = false ;
17269 PyObject * obj0 = 0 ;
17270 PyObject * obj1 = 0 ;
17271 char * kwnames[] = {
17272 (char *) "self",(char *) "fileName", NULL
17273 };
17274
17275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17277 if (!SWIG_IsOK(res1)) {
17278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17279 }
17280 arg1 = reinterpret_cast< wxSound * >(argp1);
17281 {
17282 arg2 = wxString_in_helper(obj1);
17283 if (arg2 == NULL) SWIG_fail;
17284 temp2 = true;
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (bool)(arg1)->Create((wxString const &)*arg2);
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 {
17293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17294 }
17295 {
17296 if (temp2)
17297 delete arg2;
17298 }
17299 return resultobj;
17300 fail:
17301 {
17302 if (temp2)
17303 delete arg2;
17304 }
17305 return NULL;
17306 }
17307
17308
17309 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj = 0;
17311 wxSound *arg1 = (wxSound *) 0 ;
17312 PyObject *arg2 = (PyObject *) 0 ;
17313 bool result;
17314 void *argp1 = 0 ;
17315 int res1 = 0 ;
17316 PyObject * obj0 = 0 ;
17317 PyObject * obj1 = 0 ;
17318 char * kwnames[] = {
17319 (char *) "self",(char *) "data", NULL
17320 };
17321
17322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17324 if (!SWIG_IsOK(res1)) {
17325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17326 }
17327 arg1 = reinterpret_cast< wxSound * >(argp1);
17328 arg2 = obj1;
17329 {
17330 PyThreadState* __tstate = wxPyBeginAllowThreads();
17331 result = (bool)wxSound_CreateFromData(arg1,arg2);
17332 wxPyEndAllowThreads(__tstate);
17333 if (PyErr_Occurred()) SWIG_fail;
17334 }
17335 {
17336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17337 }
17338 return resultobj;
17339 fail:
17340 return NULL;
17341 }
17342
17343
17344 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17345 PyObject *resultobj = 0;
17346 wxSound *arg1 = (wxSound *) 0 ;
17347 bool result;
17348 void *argp1 = 0 ;
17349 int res1 = 0 ;
17350 PyObject *swig_obj[1] ;
17351
17352 if (!args) SWIG_fail;
17353 swig_obj[0] = args;
17354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17355 if (!SWIG_IsOK(res1)) {
17356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17357 }
17358 arg1 = reinterpret_cast< wxSound * >(argp1);
17359 {
17360 PyThreadState* __tstate = wxPyBeginAllowThreads();
17361 result = (bool)(arg1)->IsOk();
17362 wxPyEndAllowThreads(__tstate);
17363 if (PyErr_Occurred()) SWIG_fail;
17364 }
17365 {
17366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17367 }
17368 return resultobj;
17369 fail:
17370 return NULL;
17371 }
17372
17373
17374 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17375 PyObject *resultobj = 0;
17376 wxSound *arg1 = (wxSound *) 0 ;
17377 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17378 bool result;
17379 void *argp1 = 0 ;
17380 int res1 = 0 ;
17381 unsigned int val2 ;
17382 int ecode2 = 0 ;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 char * kwnames[] = {
17386 (char *) "self",(char *) "flags", NULL
17387 };
17388
17389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17391 if (!SWIG_IsOK(res1)) {
17392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17393 }
17394 arg1 = reinterpret_cast< wxSound * >(argp1);
17395 if (obj1) {
17396 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17397 if (!SWIG_IsOK(ecode2)) {
17398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17399 }
17400 arg2 = static_cast< unsigned int >(val2);
17401 }
17402 {
17403 if (!wxPyCheckForApp()) SWIG_fail;
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 result = (bool)((wxSound const *)arg1)->Play(arg2);
17406 wxPyEndAllowThreads(__tstate);
17407 if (PyErr_Occurred()) SWIG_fail;
17408 }
17409 {
17410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17411 }
17412 return resultobj;
17413 fail:
17414 return NULL;
17415 }
17416
17417
17418 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17419 PyObject *resultobj = 0;
17420 wxString *arg1 = 0 ;
17421 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17422 bool result;
17423 bool temp1 = false ;
17424 unsigned int val2 ;
17425 int ecode2 = 0 ;
17426 PyObject * obj0 = 0 ;
17427 PyObject * obj1 = 0 ;
17428 char * kwnames[] = {
17429 (char *) "filename",(char *) "flags", NULL
17430 };
17431
17432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17433 {
17434 arg1 = wxString_in_helper(obj0);
17435 if (arg1 == NULL) SWIG_fail;
17436 temp1 = true;
17437 }
17438 if (obj1) {
17439 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17440 if (!SWIG_IsOK(ecode2)) {
17441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17442 }
17443 arg2 = static_cast< unsigned int >(val2);
17444 }
17445 {
17446 if (!wxPyCheckForApp()) SWIG_fail;
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 {
17453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17454 }
17455 {
17456 if (temp1)
17457 delete arg1;
17458 }
17459 return resultobj;
17460 fail:
17461 {
17462 if (temp1)
17463 delete arg1;
17464 }
17465 return NULL;
17466 }
17467
17468
17469 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17470 PyObject *resultobj = 0;
17471
17472 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17473 {
17474 if (!wxPyCheckForApp()) SWIG_fail;
17475 PyThreadState* __tstate = wxPyBeginAllowThreads();
17476 wxSound::Stop();
17477 wxPyEndAllowThreads(__tstate);
17478 if (PyErr_Occurred()) SWIG_fail;
17479 }
17480 resultobj = SWIG_Py_Void();
17481 return resultobj;
17482 fail:
17483 return NULL;
17484 }
17485
17486
17487 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17488 PyObject *obj;
17489 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17490 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17491 return SWIG_Py_Void();
17492 }
17493
17494 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17495 return SWIG_Python_InitShadowInstance(args);
17496 }
17497
17498 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj = 0;
17500 wxString *arg1 = 0 ;
17501 wxString *arg2 = 0 ;
17502 wxString *arg3 = 0 ;
17503 wxString *arg4 = 0 ;
17504 wxFileTypeInfo *result = 0 ;
17505 bool temp1 = false ;
17506 bool temp2 = false ;
17507 bool temp3 = false ;
17508 bool temp4 = false ;
17509 PyObject * obj0 = 0 ;
17510 PyObject * obj1 = 0 ;
17511 PyObject * obj2 = 0 ;
17512 PyObject * obj3 = 0 ;
17513 char * kwnames[] = {
17514 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17515 };
17516
17517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17518 {
17519 arg1 = wxString_in_helper(obj0);
17520 if (arg1 == NULL) SWIG_fail;
17521 temp1 = true;
17522 }
17523 {
17524 arg2 = wxString_in_helper(obj1);
17525 if (arg2 == NULL) SWIG_fail;
17526 temp2 = true;
17527 }
17528 {
17529 arg3 = wxString_in_helper(obj2);
17530 if (arg3 == NULL) SWIG_fail;
17531 temp3 = true;
17532 }
17533 {
17534 arg4 = wxString_in_helper(obj3);
17535 if (arg4 == NULL) SWIG_fail;
17536 temp4 = true;
17537 }
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17541 wxPyEndAllowThreads(__tstate);
17542 if (PyErr_Occurred()) SWIG_fail;
17543 }
17544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17545 {
17546 if (temp1)
17547 delete arg1;
17548 }
17549 {
17550 if (temp2)
17551 delete arg2;
17552 }
17553 {
17554 if (temp3)
17555 delete arg3;
17556 }
17557 {
17558 if (temp4)
17559 delete arg4;
17560 }
17561 return resultobj;
17562 fail:
17563 {
17564 if (temp1)
17565 delete arg1;
17566 }
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 {
17572 if (temp3)
17573 delete arg3;
17574 }
17575 {
17576 if (temp4)
17577 delete arg4;
17578 }
17579 return NULL;
17580 }
17581
17582
17583 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17584 PyObject *resultobj = 0;
17585 wxArrayString *arg1 = 0 ;
17586 wxFileTypeInfo *result = 0 ;
17587 bool temp1 = false ;
17588 PyObject * obj0 = 0 ;
17589 char * kwnames[] = {
17590 (char *) "sArray", NULL
17591 };
17592
17593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17594 {
17595 if (! PySequence_Check(obj0)) {
17596 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17597 SWIG_fail;
17598 }
17599 arg1 = new wxArrayString;
17600 temp1 = true;
17601 int i, len=PySequence_Length(obj0);
17602 for (i=0; i<len; i++) {
17603 PyObject* item = PySequence_GetItem(obj0, i);
17604 wxString* s = wxString_in_helper(item);
17605 if (PyErr_Occurred()) SWIG_fail;
17606 arg1->Add(*s);
17607 delete s;
17608 Py_DECREF(item);
17609 }
17610 }
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17618 {
17619 if (temp1) delete arg1;
17620 }
17621 return resultobj;
17622 fail:
17623 {
17624 if (temp1) delete arg1;
17625 }
17626 return NULL;
17627 }
17628
17629
17630 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17631 PyObject *resultobj = 0;
17632 wxFileTypeInfo *result = 0 ;
17633
17634 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17635 {
17636 PyThreadState* __tstate = wxPyBeginAllowThreads();
17637 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17638 wxPyEndAllowThreads(__tstate);
17639 if (PyErr_Occurred()) SWIG_fail;
17640 }
17641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17642 return resultobj;
17643 fail:
17644 return NULL;
17645 }
17646
17647
17648 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17649 PyObject *resultobj = 0;
17650 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17651 bool result;
17652 void *argp1 = 0 ;
17653 int res1 = 0 ;
17654 PyObject *swig_obj[1] ;
17655
17656 if (!args) SWIG_fail;
17657 swig_obj[0] = args;
17658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17659 if (!SWIG_IsOK(res1)) {
17660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17661 }
17662 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17663 {
17664 PyThreadState* __tstate = wxPyBeginAllowThreads();
17665 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17666 wxPyEndAllowThreads(__tstate);
17667 if (PyErr_Occurred()) SWIG_fail;
17668 }
17669 {
17670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17671 }
17672 return resultobj;
17673 fail:
17674 return NULL;
17675 }
17676
17677
17678 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17679 PyObject *resultobj = 0;
17680 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17681 wxString *arg2 = 0 ;
17682 int arg3 = (int) 0 ;
17683 void *argp1 = 0 ;
17684 int res1 = 0 ;
17685 bool temp2 = false ;
17686 int val3 ;
17687 int ecode3 = 0 ;
17688 PyObject * obj0 = 0 ;
17689 PyObject * obj1 = 0 ;
17690 PyObject * obj2 = 0 ;
17691 char * kwnames[] = {
17692 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17693 };
17694
17695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17697 if (!SWIG_IsOK(res1)) {
17698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17699 }
17700 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17701 {
17702 arg2 = wxString_in_helper(obj1);
17703 if (arg2 == NULL) SWIG_fail;
17704 temp2 = true;
17705 }
17706 if (obj2) {
17707 ecode3 = SWIG_AsVal_int(obj2, &val3);
17708 if (!SWIG_IsOK(ecode3)) {
17709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17710 }
17711 arg3 = static_cast< int >(val3);
17712 }
17713 {
17714 PyThreadState* __tstate = wxPyBeginAllowThreads();
17715 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17716 wxPyEndAllowThreads(__tstate);
17717 if (PyErr_Occurred()) SWIG_fail;
17718 }
17719 resultobj = SWIG_Py_Void();
17720 {
17721 if (temp2)
17722 delete arg2;
17723 }
17724 return resultobj;
17725 fail:
17726 {
17727 if (temp2)
17728 delete arg2;
17729 }
17730 return NULL;
17731 }
17732
17733
17734 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17735 PyObject *resultobj = 0;
17736 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17737 wxString *arg2 = 0 ;
17738 void *argp1 = 0 ;
17739 int res1 = 0 ;
17740 bool temp2 = false ;
17741 PyObject * obj0 = 0 ;
17742 PyObject * obj1 = 0 ;
17743 char * kwnames[] = {
17744 (char *) "self",(char *) "shortDesc", NULL
17745 };
17746
17747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17749 if (!SWIG_IsOK(res1)) {
17750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17751 }
17752 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17753 {
17754 arg2 = wxString_in_helper(obj1);
17755 if (arg2 == NULL) SWIG_fail;
17756 temp2 = true;
17757 }
17758 {
17759 PyThreadState* __tstate = wxPyBeginAllowThreads();
17760 (arg1)->SetShortDesc((wxString const &)*arg2);
17761 wxPyEndAllowThreads(__tstate);
17762 if (PyErr_Occurred()) SWIG_fail;
17763 }
17764 resultobj = SWIG_Py_Void();
17765 {
17766 if (temp2)
17767 delete arg2;
17768 }
17769 return resultobj;
17770 fail:
17771 {
17772 if (temp2)
17773 delete arg2;
17774 }
17775 return NULL;
17776 }
17777
17778
17779 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17780 PyObject *resultobj = 0;
17781 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17782 wxString *result = 0 ;
17783 void *argp1 = 0 ;
17784 int res1 = 0 ;
17785 PyObject *swig_obj[1] ;
17786
17787 if (!args) SWIG_fail;
17788 swig_obj[0] = args;
17789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17790 if (!SWIG_IsOK(res1)) {
17791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17792 }
17793 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17794 {
17795 PyThreadState* __tstate = wxPyBeginAllowThreads();
17796 {
17797 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17798 result = (wxString *) &_result_ref;
17799 }
17800 wxPyEndAllowThreads(__tstate);
17801 if (PyErr_Occurred()) SWIG_fail;
17802 }
17803 {
17804 #if wxUSE_UNICODE
17805 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17806 #else
17807 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17808 #endif
17809 }
17810 return resultobj;
17811 fail:
17812 return NULL;
17813 }
17814
17815
17816 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17817 PyObject *resultobj = 0;
17818 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17819 wxString *result = 0 ;
17820 void *argp1 = 0 ;
17821 int res1 = 0 ;
17822 PyObject *swig_obj[1] ;
17823
17824 if (!args) SWIG_fail;
17825 swig_obj[0] = args;
17826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17827 if (!SWIG_IsOK(res1)) {
17828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17829 }
17830 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17831 {
17832 PyThreadState* __tstate = wxPyBeginAllowThreads();
17833 {
17834 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17835 result = (wxString *) &_result_ref;
17836 }
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 {
17841 #if wxUSE_UNICODE
17842 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17843 #else
17844 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17845 #endif
17846 }
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17854 PyObject *resultobj = 0;
17855 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17856 wxString *result = 0 ;
17857 void *argp1 = 0 ;
17858 int res1 = 0 ;
17859 PyObject *swig_obj[1] ;
17860
17861 if (!args) SWIG_fail;
17862 swig_obj[0] = args;
17863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17864 if (!SWIG_IsOK(res1)) {
17865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17866 }
17867 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17868 {
17869 PyThreadState* __tstate = wxPyBeginAllowThreads();
17870 {
17871 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17872 result = (wxString *) &_result_ref;
17873 }
17874 wxPyEndAllowThreads(__tstate);
17875 if (PyErr_Occurred()) SWIG_fail;
17876 }
17877 {
17878 #if wxUSE_UNICODE
17879 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17880 #else
17881 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17882 #endif
17883 }
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17891 PyObject *resultobj = 0;
17892 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17893 wxString *result = 0 ;
17894 void *argp1 = 0 ;
17895 int res1 = 0 ;
17896 PyObject *swig_obj[1] ;
17897
17898 if (!args) SWIG_fail;
17899 swig_obj[0] = args;
17900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17901 if (!SWIG_IsOK(res1)) {
17902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17903 }
17904 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17905 {
17906 PyThreadState* __tstate = wxPyBeginAllowThreads();
17907 {
17908 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17909 result = (wxString *) &_result_ref;
17910 }
17911 wxPyEndAllowThreads(__tstate);
17912 if (PyErr_Occurred()) SWIG_fail;
17913 }
17914 {
17915 #if wxUSE_UNICODE
17916 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17917 #else
17918 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17919 #endif
17920 }
17921 return resultobj;
17922 fail:
17923 return NULL;
17924 }
17925
17926
17927 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17928 PyObject *resultobj = 0;
17929 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17930 wxString *result = 0 ;
17931 void *argp1 = 0 ;
17932 int res1 = 0 ;
17933 PyObject *swig_obj[1] ;
17934
17935 if (!args) SWIG_fail;
17936 swig_obj[0] = args;
17937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17938 if (!SWIG_IsOK(res1)) {
17939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17940 }
17941 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17942 {
17943 PyThreadState* __tstate = wxPyBeginAllowThreads();
17944 {
17945 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17946 result = (wxString *) &_result_ref;
17947 }
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 {
17952 #if wxUSE_UNICODE
17953 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17954 #else
17955 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17956 #endif
17957 }
17958 return resultobj;
17959 fail:
17960 return NULL;
17961 }
17962
17963
17964 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17965 PyObject *resultobj = 0;
17966 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17967 wxArrayString *result = 0 ;
17968 void *argp1 = 0 ;
17969 int res1 = 0 ;
17970 PyObject *swig_obj[1] ;
17971
17972 if (!args) SWIG_fail;
17973 swig_obj[0] = args;
17974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17975 if (!SWIG_IsOK(res1)) {
17976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17977 }
17978 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 {
17982 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17983 result = (wxArrayString *) &_result_ref;
17984 }
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 {
17989 resultobj = wxArrayString2PyList_helper(*result);
17990 }
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17998 PyObject *resultobj = 0;
17999 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18000 size_t result;
18001 void *argp1 = 0 ;
18002 int res1 = 0 ;
18003 PyObject *swig_obj[1] ;
18004
18005 if (!args) SWIG_fail;
18006 swig_obj[0] = args;
18007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18008 if (!SWIG_IsOK(res1)) {
18009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18010 }
18011 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18012 {
18013 PyThreadState* __tstate = wxPyBeginAllowThreads();
18014 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
18015 wxPyEndAllowThreads(__tstate);
18016 if (PyErr_Occurred()) SWIG_fail;
18017 }
18018 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18019 return resultobj;
18020 fail:
18021 return NULL;
18022 }
18023
18024
18025 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18026 PyObject *resultobj = 0;
18027 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18028 wxString *result = 0 ;
18029 void *argp1 = 0 ;
18030 int res1 = 0 ;
18031 PyObject *swig_obj[1] ;
18032
18033 if (!args) SWIG_fail;
18034 swig_obj[0] = args;
18035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18036 if (!SWIG_IsOK(res1)) {
18037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18038 }
18039 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 {
18043 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18044 result = (wxString *) &_result_ref;
18045 }
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 {
18050 #if wxUSE_UNICODE
18051 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18052 #else
18053 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18054 #endif
18055 }
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063 PyObject *resultobj = 0;
18064 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18065 int result;
18066 void *argp1 = 0 ;
18067 int res1 = 0 ;
18068 PyObject *swig_obj[1] ;
18069
18070 if (!args) SWIG_fail;
18071 swig_obj[0] = args;
18072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18073 if (!SWIG_IsOK(res1)) {
18074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18075 }
18076 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18077 {
18078 PyThreadState* __tstate = wxPyBeginAllowThreads();
18079 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18080 wxPyEndAllowThreads(__tstate);
18081 if (PyErr_Occurred()) SWIG_fail;
18082 }
18083 resultobj = SWIG_From_int(static_cast< int >(result));
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18091 PyObject *obj;
18092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18093 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18094 return SWIG_Py_Void();
18095 }
18096
18097 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18098 return SWIG_Python_InitShadowInstance(args);
18099 }
18100
18101 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18102 PyObject *resultobj = 0;
18103 wxFileTypeInfo *arg1 = 0 ;
18104 wxFileType *result = 0 ;
18105 void *argp1 = 0 ;
18106 int res1 = 0 ;
18107 PyObject * obj0 = 0 ;
18108 char * kwnames[] = {
18109 (char *) "ftInfo", NULL
18110 };
18111
18112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18113 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18116 }
18117 if (!argp1) {
18118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18119 }
18120 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18121 {
18122 PyThreadState* __tstate = wxPyBeginAllowThreads();
18123 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18124 wxPyEndAllowThreads(__tstate);
18125 if (PyErr_Occurred()) SWIG_fail;
18126 }
18127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18128 return resultobj;
18129 fail:
18130 return NULL;
18131 }
18132
18133
18134 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18135 PyObject *resultobj = 0;
18136 wxFileType *arg1 = (wxFileType *) 0 ;
18137 void *argp1 = 0 ;
18138 int res1 = 0 ;
18139 PyObject *swig_obj[1] ;
18140
18141 if (!args) SWIG_fail;
18142 swig_obj[0] = args;
18143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18144 if (!SWIG_IsOK(res1)) {
18145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18146 }
18147 arg1 = reinterpret_cast< wxFileType * >(argp1);
18148 {
18149 PyThreadState* __tstate = wxPyBeginAllowThreads();
18150 delete arg1;
18151
18152 wxPyEndAllowThreads(__tstate);
18153 if (PyErr_Occurred()) SWIG_fail;
18154 }
18155 resultobj = SWIG_Py_Void();
18156 return resultobj;
18157 fail:
18158 return NULL;
18159 }
18160
18161
18162 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18163 PyObject *resultobj = 0;
18164 wxFileType *arg1 = (wxFileType *) 0 ;
18165 PyObject *result = 0 ;
18166 void *argp1 = 0 ;
18167 int res1 = 0 ;
18168 PyObject *swig_obj[1] ;
18169
18170 if (!args) SWIG_fail;
18171 swig_obj[0] = args;
18172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18173 if (!SWIG_IsOK(res1)) {
18174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18175 }
18176 arg1 = reinterpret_cast< wxFileType * >(argp1);
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (PyObject *)wxFileType_GetMimeType(arg1);
18180 wxPyEndAllowThreads(__tstate);
18181 if (PyErr_Occurred()) SWIG_fail;
18182 }
18183 resultobj = result;
18184 return resultobj;
18185 fail:
18186 return NULL;
18187 }
18188
18189
18190 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18191 PyObject *resultobj = 0;
18192 wxFileType *arg1 = (wxFileType *) 0 ;
18193 PyObject *result = 0 ;
18194 void *argp1 = 0 ;
18195 int res1 = 0 ;
18196 PyObject *swig_obj[1] ;
18197
18198 if (!args) SWIG_fail;
18199 swig_obj[0] = args;
18200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18201 if (!SWIG_IsOK(res1)) {
18202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18203 }
18204 arg1 = reinterpret_cast< wxFileType * >(argp1);
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18208 wxPyEndAllowThreads(__tstate);
18209 if (PyErr_Occurred()) SWIG_fail;
18210 }
18211 resultobj = result;
18212 return resultobj;
18213 fail:
18214 return NULL;
18215 }
18216
18217
18218 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18219 PyObject *resultobj = 0;
18220 wxFileType *arg1 = (wxFileType *) 0 ;
18221 PyObject *result = 0 ;
18222 void *argp1 = 0 ;
18223 int res1 = 0 ;
18224 PyObject *swig_obj[1] ;
18225
18226 if (!args) SWIG_fail;
18227 swig_obj[0] = args;
18228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18229 if (!SWIG_IsOK(res1)) {
18230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18231 }
18232 arg1 = reinterpret_cast< wxFileType * >(argp1);
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 result = (PyObject *)wxFileType_GetExtensions(arg1);
18236 wxPyEndAllowThreads(__tstate);
18237 if (PyErr_Occurred()) SWIG_fail;
18238 }
18239 resultobj = result;
18240 return resultobj;
18241 fail:
18242 return NULL;
18243 }
18244
18245
18246 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18247 PyObject *resultobj = 0;
18248 wxFileType *arg1 = (wxFileType *) 0 ;
18249 wxIcon *result = 0 ;
18250 void *argp1 = 0 ;
18251 int res1 = 0 ;
18252 PyObject *swig_obj[1] ;
18253
18254 if (!args) SWIG_fail;
18255 swig_obj[0] = args;
18256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18257 if (!SWIG_IsOK(res1)) {
18258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18259 }
18260 arg1 = reinterpret_cast< wxFileType * >(argp1);
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = (wxIcon *)wxFileType_GetIcon(arg1);
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18268 return resultobj;
18269 fail:
18270 return NULL;
18271 }
18272
18273
18274 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18275 PyObject *resultobj = 0;
18276 wxFileType *arg1 = (wxFileType *) 0 ;
18277 PyObject *result = 0 ;
18278 void *argp1 = 0 ;
18279 int res1 = 0 ;
18280 PyObject *swig_obj[1] ;
18281
18282 if (!args) SWIG_fail;
18283 swig_obj[0] = args;
18284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18285 if (!SWIG_IsOK(res1)) {
18286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18287 }
18288 arg1 = reinterpret_cast< wxFileType * >(argp1);
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18292 wxPyEndAllowThreads(__tstate);
18293 if (PyErr_Occurred()) SWIG_fail;
18294 }
18295 resultobj = result;
18296 return resultobj;
18297 fail:
18298 return NULL;
18299 }
18300
18301
18302 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18303 PyObject *resultobj = 0;
18304 wxFileType *arg1 = (wxFileType *) 0 ;
18305 PyObject *result = 0 ;
18306 void *argp1 = 0 ;
18307 int res1 = 0 ;
18308 PyObject *swig_obj[1] ;
18309
18310 if (!args) SWIG_fail;
18311 swig_obj[0] = args;
18312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18313 if (!SWIG_IsOK(res1)) {
18314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18315 }
18316 arg1 = reinterpret_cast< wxFileType * >(argp1);
18317 {
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 result = (PyObject *)wxFileType_GetDescription(arg1);
18320 wxPyEndAllowThreads(__tstate);
18321 if (PyErr_Occurred()) SWIG_fail;
18322 }
18323 resultobj = result;
18324 return resultobj;
18325 fail:
18326 return NULL;
18327 }
18328
18329
18330 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18331 PyObject *resultobj = 0;
18332 wxFileType *arg1 = (wxFileType *) 0 ;
18333 wxString *arg2 = 0 ;
18334 wxString const &arg3_defvalue = wxPyEmptyString ;
18335 wxString *arg3 = (wxString *) &arg3_defvalue ;
18336 PyObject *result = 0 ;
18337 void *argp1 = 0 ;
18338 int res1 = 0 ;
18339 bool temp2 = false ;
18340 bool temp3 = false ;
18341 PyObject * obj0 = 0 ;
18342 PyObject * obj1 = 0 ;
18343 PyObject * obj2 = 0 ;
18344 char * kwnames[] = {
18345 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18346 };
18347
18348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18350 if (!SWIG_IsOK(res1)) {
18351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18352 }
18353 arg1 = reinterpret_cast< wxFileType * >(argp1);
18354 {
18355 arg2 = wxString_in_helper(obj1);
18356 if (arg2 == NULL) SWIG_fail;
18357 temp2 = true;
18358 }
18359 if (obj2) {
18360 {
18361 arg3 = wxString_in_helper(obj2);
18362 if (arg3 == NULL) SWIG_fail;
18363 temp3 = true;
18364 }
18365 }
18366 {
18367 PyThreadState* __tstate = wxPyBeginAllowThreads();
18368 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18369 wxPyEndAllowThreads(__tstate);
18370 if (PyErr_Occurred()) SWIG_fail;
18371 }
18372 resultobj = result;
18373 {
18374 if (temp2)
18375 delete arg2;
18376 }
18377 {
18378 if (temp3)
18379 delete arg3;
18380 }
18381 return resultobj;
18382 fail:
18383 {
18384 if (temp2)
18385 delete arg2;
18386 }
18387 {
18388 if (temp3)
18389 delete arg3;
18390 }
18391 return NULL;
18392 }
18393
18394
18395 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18396 PyObject *resultobj = 0;
18397 wxFileType *arg1 = (wxFileType *) 0 ;
18398 wxString *arg2 = 0 ;
18399 wxString const &arg3_defvalue = wxPyEmptyString ;
18400 wxString *arg3 = (wxString *) &arg3_defvalue ;
18401 PyObject *result = 0 ;
18402 void *argp1 = 0 ;
18403 int res1 = 0 ;
18404 bool temp2 = false ;
18405 bool temp3 = false ;
18406 PyObject * obj0 = 0 ;
18407 PyObject * obj1 = 0 ;
18408 PyObject * obj2 = 0 ;
18409 char * kwnames[] = {
18410 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18411 };
18412
18413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18415 if (!SWIG_IsOK(res1)) {
18416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18417 }
18418 arg1 = reinterpret_cast< wxFileType * >(argp1);
18419 {
18420 arg2 = wxString_in_helper(obj1);
18421 if (arg2 == NULL) SWIG_fail;
18422 temp2 = true;
18423 }
18424 if (obj2) {
18425 {
18426 arg3 = wxString_in_helper(obj2);
18427 if (arg3 == NULL) SWIG_fail;
18428 temp3 = true;
18429 }
18430 }
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 resultobj = result;
18438 {
18439 if (temp2)
18440 delete arg2;
18441 }
18442 {
18443 if (temp3)
18444 delete arg3;
18445 }
18446 return resultobj;
18447 fail:
18448 {
18449 if (temp2)
18450 delete arg2;
18451 }
18452 {
18453 if (temp3)
18454 delete arg3;
18455 }
18456 return NULL;
18457 }
18458
18459
18460 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18461 PyObject *resultobj = 0;
18462 wxFileType *arg1 = (wxFileType *) 0 ;
18463 wxString *arg2 = 0 ;
18464 wxString const &arg3_defvalue = wxPyEmptyString ;
18465 wxString *arg3 = (wxString *) &arg3_defvalue ;
18466 PyObject *result = 0 ;
18467 void *argp1 = 0 ;
18468 int res1 = 0 ;
18469 bool temp2 = false ;
18470 bool temp3 = false ;
18471 PyObject * obj0 = 0 ;
18472 PyObject * obj1 = 0 ;
18473 PyObject * obj2 = 0 ;
18474 char * kwnames[] = {
18475 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18476 };
18477
18478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18480 if (!SWIG_IsOK(res1)) {
18481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18482 }
18483 arg1 = reinterpret_cast< wxFileType * >(argp1);
18484 {
18485 arg2 = wxString_in_helper(obj1);
18486 if (arg2 == NULL) SWIG_fail;
18487 temp2 = true;
18488 }
18489 if (obj2) {
18490 {
18491 arg3 = wxString_in_helper(obj2);
18492 if (arg3 == NULL) SWIG_fail;
18493 temp3 = true;
18494 }
18495 }
18496 {
18497 PyThreadState* __tstate = wxPyBeginAllowThreads();
18498 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18499 wxPyEndAllowThreads(__tstate);
18500 if (PyErr_Occurred()) SWIG_fail;
18501 }
18502 resultobj = result;
18503 {
18504 if (temp2)
18505 delete arg2;
18506 }
18507 {
18508 if (temp3)
18509 delete arg3;
18510 }
18511 return resultobj;
18512 fail:
18513 {
18514 if (temp2)
18515 delete arg2;
18516 }
18517 {
18518 if (temp3)
18519 delete arg3;
18520 }
18521 return NULL;
18522 }
18523
18524
18525 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj = 0;
18527 wxFileType *arg1 = (wxFileType *) 0 ;
18528 wxString *arg2 = 0 ;
18529 wxString *arg3 = 0 ;
18530 bool arg4 = (bool) true ;
18531 bool result;
18532 void *argp1 = 0 ;
18533 int res1 = 0 ;
18534 bool temp2 = false ;
18535 bool temp3 = false ;
18536 bool val4 ;
18537 int ecode4 = 0 ;
18538 PyObject * obj0 = 0 ;
18539 PyObject * obj1 = 0 ;
18540 PyObject * obj2 = 0 ;
18541 PyObject * obj3 = 0 ;
18542 char * kwnames[] = {
18543 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18544 };
18545
18546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18548 if (!SWIG_IsOK(res1)) {
18549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18550 }
18551 arg1 = reinterpret_cast< wxFileType * >(argp1);
18552 {
18553 arg2 = wxString_in_helper(obj1);
18554 if (arg2 == NULL) SWIG_fail;
18555 temp2 = true;
18556 }
18557 {
18558 arg3 = wxString_in_helper(obj2);
18559 if (arg3 == NULL) SWIG_fail;
18560 temp3 = true;
18561 }
18562 if (obj3) {
18563 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18564 if (!SWIG_IsOK(ecode4)) {
18565 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18566 }
18567 arg4 = static_cast< bool >(val4);
18568 }
18569 {
18570 PyThreadState* __tstate = wxPyBeginAllowThreads();
18571 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 {
18576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18577 }
18578 {
18579 if (temp2)
18580 delete arg2;
18581 }
18582 {
18583 if (temp3)
18584 delete arg3;
18585 }
18586 return resultobj;
18587 fail:
18588 {
18589 if (temp2)
18590 delete arg2;
18591 }
18592 {
18593 if (temp3)
18594 delete arg3;
18595 }
18596 return NULL;
18597 }
18598
18599
18600 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18601 PyObject *resultobj = 0;
18602 wxFileType *arg1 = (wxFileType *) 0 ;
18603 wxString const &arg2_defvalue = wxPyEmptyString ;
18604 wxString *arg2 = (wxString *) &arg2_defvalue ;
18605 int arg3 = (int) 0 ;
18606 bool result;
18607 void *argp1 = 0 ;
18608 int res1 = 0 ;
18609 bool temp2 = false ;
18610 int val3 ;
18611 int ecode3 = 0 ;
18612 PyObject * obj0 = 0 ;
18613 PyObject * obj1 = 0 ;
18614 PyObject * obj2 = 0 ;
18615 char * kwnames[] = {
18616 (char *) "self",(char *) "cmd",(char *) "index", NULL
18617 };
18618
18619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18623 }
18624 arg1 = reinterpret_cast< wxFileType * >(argp1);
18625 if (obj1) {
18626 {
18627 arg2 = wxString_in_helper(obj1);
18628 if (arg2 == NULL) SWIG_fail;
18629 temp2 = true;
18630 }
18631 }
18632 if (obj2) {
18633 ecode3 = SWIG_AsVal_int(obj2, &val3);
18634 if (!SWIG_IsOK(ecode3)) {
18635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18636 }
18637 arg3 = static_cast< int >(val3);
18638 }
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18642 wxPyEndAllowThreads(__tstate);
18643 if (PyErr_Occurred()) SWIG_fail;
18644 }
18645 {
18646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18647 }
18648 {
18649 if (temp2)
18650 delete arg2;
18651 }
18652 return resultobj;
18653 fail:
18654 {
18655 if (temp2)
18656 delete arg2;
18657 }
18658 return NULL;
18659 }
18660
18661
18662 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18663 PyObject *resultobj = 0;
18664 wxFileType *arg1 = (wxFileType *) 0 ;
18665 bool result;
18666 void *argp1 = 0 ;
18667 int res1 = 0 ;
18668 PyObject *swig_obj[1] ;
18669
18670 if (!args) SWIG_fail;
18671 swig_obj[0] = args;
18672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18675 }
18676 arg1 = reinterpret_cast< wxFileType * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 result = (bool)(arg1)->Unassociate();
18680 wxPyEndAllowThreads(__tstate);
18681 if (PyErr_Occurred()) SWIG_fail;
18682 }
18683 {
18684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18685 }
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18693 PyObject *resultobj = 0;
18694 wxString *arg1 = 0 ;
18695 wxString *arg2 = 0 ;
18696 wxString const &arg3_defvalue = wxPyEmptyString ;
18697 wxString *arg3 = (wxString *) &arg3_defvalue ;
18698 wxString result;
18699 bool temp1 = false ;
18700 bool temp2 = false ;
18701 bool temp3 = false ;
18702 PyObject * obj0 = 0 ;
18703 PyObject * obj1 = 0 ;
18704 PyObject * obj2 = 0 ;
18705 char * kwnames[] = {
18706 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18707 };
18708
18709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18710 {
18711 arg1 = wxString_in_helper(obj0);
18712 if (arg1 == NULL) SWIG_fail;
18713 temp1 = true;
18714 }
18715 {
18716 arg2 = wxString_in_helper(obj1);
18717 if (arg2 == NULL) SWIG_fail;
18718 temp2 = true;
18719 }
18720 if (obj2) {
18721 {
18722 arg3 = wxString_in_helper(obj2);
18723 if (arg3 == NULL) SWIG_fail;
18724 temp3 = true;
18725 }
18726 }
18727 {
18728 PyThreadState* __tstate = wxPyBeginAllowThreads();
18729 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18730 wxPyEndAllowThreads(__tstate);
18731 if (PyErr_Occurred()) SWIG_fail;
18732 }
18733 {
18734 #if wxUSE_UNICODE
18735 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18736 #else
18737 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18738 #endif
18739 }
18740 {
18741 if (temp1)
18742 delete arg1;
18743 }
18744 {
18745 if (temp2)
18746 delete arg2;
18747 }
18748 {
18749 if (temp3)
18750 delete arg3;
18751 }
18752 return resultobj;
18753 fail:
18754 {
18755 if (temp1)
18756 delete arg1;
18757 }
18758 {
18759 if (temp2)
18760 delete arg2;
18761 }
18762 {
18763 if (temp3)
18764 delete arg3;
18765 }
18766 return NULL;
18767 }
18768
18769
18770 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771 PyObject *obj;
18772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18773 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18774 return SWIG_Py_Void();
18775 }
18776
18777 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18778 return SWIG_Python_InitShadowInstance(args);
18779 }
18780
18781 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18782 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18783 return 1;
18784 }
18785
18786
18787 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18788 PyObject *pyobj = 0;
18789
18790 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18791 return pyobj;
18792 }
18793
18794
18795 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18796 PyObject *resultobj = 0;
18797 wxString *arg1 = 0 ;
18798 wxString *arg2 = 0 ;
18799 bool result;
18800 bool temp1 = false ;
18801 bool temp2 = false ;
18802 PyObject * obj0 = 0 ;
18803 PyObject * obj1 = 0 ;
18804 char * kwnames[] = {
18805 (char *) "mimeType",(char *) "wildcard", NULL
18806 };
18807
18808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18809 {
18810 arg1 = wxString_in_helper(obj0);
18811 if (arg1 == NULL) SWIG_fail;
18812 temp1 = true;
18813 }
18814 {
18815 arg2 = wxString_in_helper(obj1);
18816 if (arg2 == NULL) SWIG_fail;
18817 temp2 = true;
18818 }
18819 {
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 {
18826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18827 }
18828 {
18829 if (temp1)
18830 delete arg1;
18831 }
18832 {
18833 if (temp2)
18834 delete arg2;
18835 }
18836 return resultobj;
18837 fail:
18838 {
18839 if (temp1)
18840 delete arg1;
18841 }
18842 {
18843 if (temp2)
18844 delete arg2;
18845 }
18846 return NULL;
18847 }
18848
18849
18850 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18851 PyObject *resultobj = 0;
18852 wxMimeTypesManager *result = 0 ;
18853
18854 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18869 PyObject *resultobj = 0;
18870 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18871 int arg2 = (int) wxMAILCAP_ALL ;
18872 wxString const &arg3_defvalue = wxPyEmptyString ;
18873 wxString *arg3 = (wxString *) &arg3_defvalue ;
18874 void *argp1 = 0 ;
18875 int res1 = 0 ;
18876 int val2 ;
18877 int ecode2 = 0 ;
18878 bool temp3 = false ;
18879 PyObject * obj0 = 0 ;
18880 PyObject * obj1 = 0 ;
18881 PyObject * obj2 = 0 ;
18882 char * kwnames[] = {
18883 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18884 };
18885
18886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18888 if (!SWIG_IsOK(res1)) {
18889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18890 }
18891 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18892 if (obj1) {
18893 ecode2 = SWIG_AsVal_int(obj1, &val2);
18894 if (!SWIG_IsOK(ecode2)) {
18895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18896 }
18897 arg2 = static_cast< int >(val2);
18898 }
18899 if (obj2) {
18900 {
18901 arg3 = wxString_in_helper(obj2);
18902 if (arg3 == NULL) SWIG_fail;
18903 temp3 = true;
18904 }
18905 }
18906 {
18907 PyThreadState* __tstate = wxPyBeginAllowThreads();
18908 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18909 wxPyEndAllowThreads(__tstate);
18910 if (PyErr_Occurred()) SWIG_fail;
18911 }
18912 resultobj = SWIG_Py_Void();
18913 {
18914 if (temp3)
18915 delete arg3;
18916 }
18917 return resultobj;
18918 fail:
18919 {
18920 if (temp3)
18921 delete arg3;
18922 }
18923 return NULL;
18924 }
18925
18926
18927 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18928 PyObject *resultobj = 0;
18929 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18930 void *argp1 = 0 ;
18931 int res1 = 0 ;
18932 PyObject *swig_obj[1] ;
18933
18934 if (!args) SWIG_fail;
18935 swig_obj[0] = args;
18936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18937 if (!SWIG_IsOK(res1)) {
18938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18939 }
18940 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18941 {
18942 PyThreadState* __tstate = wxPyBeginAllowThreads();
18943 (arg1)->ClearData();
18944 wxPyEndAllowThreads(__tstate);
18945 if (PyErr_Occurred()) SWIG_fail;
18946 }
18947 resultobj = SWIG_Py_Void();
18948 return resultobj;
18949 fail:
18950 return NULL;
18951 }
18952
18953
18954 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18955 PyObject *resultobj = 0;
18956 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18957 wxString *arg2 = 0 ;
18958 wxFileType *result = 0 ;
18959 void *argp1 = 0 ;
18960 int res1 = 0 ;
18961 bool temp2 = false ;
18962 PyObject * obj0 = 0 ;
18963 PyObject * obj1 = 0 ;
18964 char * kwnames[] = {
18965 (char *) "self",(char *) "ext", NULL
18966 };
18967
18968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18970 if (!SWIG_IsOK(res1)) {
18971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18972 }
18973 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18974 {
18975 arg2 = wxString_in_helper(obj1);
18976 if (arg2 == NULL) SWIG_fail;
18977 temp2 = true;
18978 }
18979 {
18980 PyThreadState* __tstate = wxPyBeginAllowThreads();
18981 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18982 wxPyEndAllowThreads(__tstate);
18983 if (PyErr_Occurred()) SWIG_fail;
18984 }
18985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18986 {
18987 if (temp2)
18988 delete arg2;
18989 }
18990 return resultobj;
18991 fail:
18992 {
18993 if (temp2)
18994 delete arg2;
18995 }
18996 return NULL;
18997 }
18998
18999
19000 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19001 PyObject *resultobj = 0;
19002 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19003 wxString *arg2 = 0 ;
19004 wxFileType *result = 0 ;
19005 void *argp1 = 0 ;
19006 int res1 = 0 ;
19007 bool temp2 = false ;
19008 PyObject * obj0 = 0 ;
19009 PyObject * obj1 = 0 ;
19010 char * kwnames[] = {
19011 (char *) "self",(char *) "mimeType", NULL
19012 };
19013
19014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
19015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19016 if (!SWIG_IsOK(res1)) {
19017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19018 }
19019 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19020 {
19021 arg2 = wxString_in_helper(obj1);
19022 if (arg2 == NULL) SWIG_fail;
19023 temp2 = true;
19024 }
19025 {
19026 PyThreadState* __tstate = wxPyBeginAllowThreads();
19027 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19028 wxPyEndAllowThreads(__tstate);
19029 if (PyErr_Occurred()) SWIG_fail;
19030 }
19031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19032 {
19033 if (temp2)
19034 delete arg2;
19035 }
19036 return resultobj;
19037 fail:
19038 {
19039 if (temp2)
19040 delete arg2;
19041 }
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19047 PyObject *resultobj = 0;
19048 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19049 wxString *arg2 = 0 ;
19050 bool arg3 = (bool) false ;
19051 bool result;
19052 void *argp1 = 0 ;
19053 int res1 = 0 ;
19054 bool temp2 = false ;
19055 bool val3 ;
19056 int ecode3 = 0 ;
19057 PyObject * obj0 = 0 ;
19058 PyObject * obj1 = 0 ;
19059 PyObject * obj2 = 0 ;
19060 char * kwnames[] = {
19061 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19062 };
19063
19064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19066 if (!SWIG_IsOK(res1)) {
19067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19068 }
19069 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19070 {
19071 arg2 = wxString_in_helper(obj1);
19072 if (arg2 == NULL) SWIG_fail;
19073 temp2 = true;
19074 }
19075 if (obj2) {
19076 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19077 if (!SWIG_IsOK(ecode3)) {
19078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19079 }
19080 arg3 = static_cast< bool >(val3);
19081 }
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 {
19089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19090 }
19091 {
19092 if (temp2)
19093 delete arg2;
19094 }
19095 return resultobj;
19096 fail:
19097 {
19098 if (temp2)
19099 delete arg2;
19100 }
19101 return NULL;
19102 }
19103
19104
19105 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19106 PyObject *resultobj = 0;
19107 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19108 wxString *arg2 = 0 ;
19109 bool result;
19110 void *argp1 = 0 ;
19111 int res1 = 0 ;
19112 bool temp2 = false ;
19113 PyObject * obj0 = 0 ;
19114 PyObject * obj1 = 0 ;
19115 char * kwnames[] = {
19116 (char *) "self",(char *) "filename", NULL
19117 };
19118
19119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19121 if (!SWIG_IsOK(res1)) {
19122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19123 }
19124 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19125 {
19126 arg2 = wxString_in_helper(obj1);
19127 if (arg2 == NULL) SWIG_fail;
19128 temp2 = true;
19129 }
19130 {
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19133 wxPyEndAllowThreads(__tstate);
19134 if (PyErr_Occurred()) SWIG_fail;
19135 }
19136 {
19137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19138 }
19139 {
19140 if (temp2)
19141 delete arg2;
19142 }
19143 return resultobj;
19144 fail:
19145 {
19146 if (temp2)
19147 delete arg2;
19148 }
19149 return NULL;
19150 }
19151
19152
19153 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19154 PyObject *resultobj = 0;
19155 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19156 PyObject *result = 0 ;
19157 void *argp1 = 0 ;
19158 int res1 = 0 ;
19159 PyObject *swig_obj[1] ;
19160
19161 if (!args) SWIG_fail;
19162 swig_obj[0] = args;
19163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19164 if (!SWIG_IsOK(res1)) {
19165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19166 }
19167 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 resultobj = result;
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19182 PyObject *resultobj = 0;
19183 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19184 wxFileTypeInfo *arg2 = 0 ;
19185 void *argp1 = 0 ;
19186 int res1 = 0 ;
19187 void *argp2 = 0 ;
19188 int res2 = 0 ;
19189 PyObject * obj0 = 0 ;
19190 PyObject * obj1 = 0 ;
19191 char * kwnames[] = {
19192 (char *) "self",(char *) "ft", NULL
19193 };
19194
19195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19197 if (!SWIG_IsOK(res1)) {
19198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19199 }
19200 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19201 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19202 if (!SWIG_IsOK(res2)) {
19203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19204 }
19205 if (!argp2) {
19206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19207 }
19208 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19209 {
19210 PyThreadState* __tstate = wxPyBeginAllowThreads();
19211 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19212 wxPyEndAllowThreads(__tstate);
19213 if (PyErr_Occurred()) SWIG_fail;
19214 }
19215 resultobj = SWIG_Py_Void();
19216 return resultobj;
19217 fail:
19218 return NULL;
19219 }
19220
19221
19222 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19223 PyObject *resultobj = 0;
19224 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19225 wxFileTypeInfo *arg2 = 0 ;
19226 wxFileType *result = 0 ;
19227 void *argp1 = 0 ;
19228 int res1 = 0 ;
19229 void *argp2 = 0 ;
19230 int res2 = 0 ;
19231 PyObject * obj0 = 0 ;
19232 PyObject * obj1 = 0 ;
19233 char * kwnames[] = {
19234 (char *) "self",(char *) "ftInfo", NULL
19235 };
19236
19237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19239 if (!SWIG_IsOK(res1)) {
19240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19241 }
19242 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19244 if (!SWIG_IsOK(res2)) {
19245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19246 }
19247 if (!argp2) {
19248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19249 }
19250 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19251 {
19252 PyThreadState* __tstate = wxPyBeginAllowThreads();
19253 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj = 0;
19266 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19267 wxFileType *arg2 = (wxFileType *) 0 ;
19268 bool result;
19269 void *argp1 = 0 ;
19270 int res1 = 0 ;
19271 void *argp2 = 0 ;
19272 int res2 = 0 ;
19273 PyObject * obj0 = 0 ;
19274 PyObject * obj1 = 0 ;
19275 char * kwnames[] = {
19276 (char *) "self",(char *) "ft", NULL
19277 };
19278
19279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19281 if (!SWIG_IsOK(res1)) {
19282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19283 }
19284 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19286 if (!SWIG_IsOK(res2)) {
19287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19288 }
19289 arg2 = reinterpret_cast< wxFileType * >(argp2);
19290 {
19291 PyThreadState* __tstate = wxPyBeginAllowThreads();
19292 result = (bool)(arg1)->Unassociate(arg2);
19293 wxPyEndAllowThreads(__tstate);
19294 if (PyErr_Occurred()) SWIG_fail;
19295 }
19296 {
19297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19298 }
19299 return resultobj;
19300 fail:
19301 return NULL;
19302 }
19303
19304
19305 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19306 PyObject *resultobj = 0;
19307 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19308 void *argp1 = 0 ;
19309 int res1 = 0 ;
19310 PyObject *swig_obj[1] ;
19311
19312 if (!args) SWIG_fail;
19313 swig_obj[0] = args;
19314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19315 if (!SWIG_IsOK(res1)) {
19316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19317 }
19318 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 delete arg1;
19322
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 resultobj = SWIG_Py_Void();
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19334 PyObject *obj;
19335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19336 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19337 return SWIG_Py_Void();
19338 }
19339
19340 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19341 return SWIG_Python_InitShadowInstance(args);
19342 }
19343
19344 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19345 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19346 return 1;
19347 }
19348
19349
19350 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19351 PyObject *pyobj = 0;
19352
19353 {
19354 #if wxUSE_UNICODE
19355 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19356 #else
19357 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19358 #endif
19359 }
19360 return pyobj;
19361 }
19362
19363
19364 SWIGINTERN int ART_MENU_set(PyObject *) {
19365 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19366 return 1;
19367 }
19368
19369
19370 SWIGINTERN PyObject *ART_MENU_get(void) {
19371 PyObject *pyobj = 0;
19372
19373 {
19374 #if wxUSE_UNICODE
19375 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19376 #else
19377 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19378 #endif
19379 }
19380 return pyobj;
19381 }
19382
19383
19384 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19385 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19386 return 1;
19387 }
19388
19389
19390 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19391 PyObject *pyobj = 0;
19392
19393 {
19394 #if wxUSE_UNICODE
19395 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19396 #else
19397 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19398 #endif
19399 }
19400 return pyobj;
19401 }
19402
19403
19404 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19405 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19406 return 1;
19407 }
19408
19409
19410 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19411 PyObject *pyobj = 0;
19412
19413 {
19414 #if wxUSE_UNICODE
19415 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19416 #else
19417 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19418 #endif
19419 }
19420 return pyobj;
19421 }
19422
19423
19424 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19425 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19426 return 1;
19427 }
19428
19429
19430 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19431 PyObject *pyobj = 0;
19432
19433 {
19434 #if wxUSE_UNICODE
19435 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19436 #else
19437 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19438 #endif
19439 }
19440 return pyobj;
19441 }
19442
19443
19444 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19445 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19446 return 1;
19447 }
19448
19449
19450 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19451 PyObject *pyobj = 0;
19452
19453 {
19454 #if wxUSE_UNICODE
19455 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19456 #else
19457 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19458 #endif
19459 }
19460 return pyobj;
19461 }
19462
19463
19464 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19465 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19466 return 1;
19467 }
19468
19469
19470 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19471 PyObject *pyobj = 0;
19472
19473 {
19474 #if wxUSE_UNICODE
19475 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19476 #else
19477 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19478 #endif
19479 }
19480 return pyobj;
19481 }
19482
19483
19484 SWIGINTERN int ART_OTHER_set(PyObject *) {
19485 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19486 return 1;
19487 }
19488
19489
19490 SWIGINTERN PyObject *ART_OTHER_get(void) {
19491 PyObject *pyobj = 0;
19492
19493 {
19494 #if wxUSE_UNICODE
19495 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19496 #else
19497 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19498 #endif
19499 }
19500 return pyobj;
19501 }
19502
19503
19504 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19505 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19506 return 1;
19507 }
19508
19509
19510 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19511 PyObject *pyobj = 0;
19512
19513 {
19514 #if wxUSE_UNICODE
19515 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19516 #else
19517 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19518 #endif
19519 }
19520 return pyobj;
19521 }
19522
19523
19524 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19525 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19526 return 1;
19527 }
19528
19529
19530 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19531 PyObject *pyobj = 0;
19532
19533 {
19534 #if wxUSE_UNICODE
19535 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19536 #else
19537 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19538 #endif
19539 }
19540 return pyobj;
19541 }
19542
19543
19544 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19545 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19546 return 1;
19547 }
19548
19549
19550 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19551 PyObject *pyobj = 0;
19552
19553 {
19554 #if wxUSE_UNICODE
19555 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19556 #else
19557 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19558 #endif
19559 }
19560 return pyobj;
19561 }
19562
19563
19564 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19565 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19566 return 1;
19567 }
19568
19569
19570 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19571 PyObject *pyobj = 0;
19572
19573 {
19574 #if wxUSE_UNICODE
19575 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19576 #else
19577 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19578 #endif
19579 }
19580 return pyobj;
19581 }
19582
19583
19584 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19585 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19586 return 1;
19587 }
19588
19589
19590 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19591 PyObject *pyobj = 0;
19592
19593 {
19594 #if wxUSE_UNICODE
19595 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19596 #else
19597 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19598 #endif
19599 }
19600 return pyobj;
19601 }
19602
19603
19604 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19605 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19606 return 1;
19607 }
19608
19609
19610 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19611 PyObject *pyobj = 0;
19612
19613 {
19614 #if wxUSE_UNICODE
19615 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19616 #else
19617 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19618 #endif
19619 }
19620 return pyobj;
19621 }
19622
19623
19624 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19625 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19626 return 1;
19627 }
19628
19629
19630 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19631 PyObject *pyobj = 0;
19632
19633 {
19634 #if wxUSE_UNICODE
19635 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19636 #else
19637 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19638 #endif
19639 }
19640 return pyobj;
19641 }
19642
19643
19644 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19645 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19646 return 1;
19647 }
19648
19649
19650 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19651 PyObject *pyobj = 0;
19652
19653 {
19654 #if wxUSE_UNICODE
19655 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19656 #else
19657 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19658 #endif
19659 }
19660 return pyobj;
19661 }
19662
19663
19664 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19665 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19666 return 1;
19667 }
19668
19669
19670 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19671 PyObject *pyobj = 0;
19672
19673 {
19674 #if wxUSE_UNICODE
19675 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19676 #else
19677 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19678 #endif
19679 }
19680 return pyobj;
19681 }
19682
19683
19684 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19685 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19686 return 1;
19687 }
19688
19689
19690 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19691 PyObject *pyobj = 0;
19692
19693 {
19694 #if wxUSE_UNICODE
19695 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19696 #else
19697 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19698 #endif
19699 }
19700 return pyobj;
19701 }
19702
19703
19704 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19705 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19706 return 1;
19707 }
19708
19709
19710 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19711 PyObject *pyobj = 0;
19712
19713 {
19714 #if wxUSE_UNICODE
19715 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19716 #else
19717 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19718 #endif
19719 }
19720 return pyobj;
19721 }
19722
19723
19724 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19725 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19726 return 1;
19727 }
19728
19729
19730 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19731 PyObject *pyobj = 0;
19732
19733 {
19734 #if wxUSE_UNICODE
19735 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19736 #else
19737 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19738 #endif
19739 }
19740 return pyobj;
19741 }
19742
19743
19744 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19745 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19746 return 1;
19747 }
19748
19749
19750 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19751 PyObject *pyobj = 0;
19752
19753 {
19754 #if wxUSE_UNICODE
19755 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19756 #else
19757 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19758 #endif
19759 }
19760 return pyobj;
19761 }
19762
19763
19764 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19765 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19766 return 1;
19767 }
19768
19769
19770 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19771 PyObject *pyobj = 0;
19772
19773 {
19774 #if wxUSE_UNICODE
19775 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19776 #else
19777 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19778 #endif
19779 }
19780 return pyobj;
19781 }
19782
19783
19784 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19785 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19786 return 1;
19787 }
19788
19789
19790 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19791 PyObject *pyobj = 0;
19792
19793 {
19794 #if wxUSE_UNICODE
19795 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19796 #else
19797 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19798 #endif
19799 }
19800 return pyobj;
19801 }
19802
19803
19804 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19805 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19806 return 1;
19807 }
19808
19809
19810 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19811 PyObject *pyobj = 0;
19812
19813 {
19814 #if wxUSE_UNICODE
19815 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19816 #else
19817 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19818 #endif
19819 }
19820 return pyobj;
19821 }
19822
19823
19824 SWIGINTERN int ART_PRINT_set(PyObject *) {
19825 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19826 return 1;
19827 }
19828
19829
19830 SWIGINTERN PyObject *ART_PRINT_get(void) {
19831 PyObject *pyobj = 0;
19832
19833 {
19834 #if wxUSE_UNICODE
19835 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19836 #else
19837 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19838 #endif
19839 }
19840 return pyobj;
19841 }
19842
19843
19844 SWIGINTERN int ART_HELP_set(PyObject *) {
19845 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19846 return 1;
19847 }
19848
19849
19850 SWIGINTERN PyObject *ART_HELP_get(void) {
19851 PyObject *pyobj = 0;
19852
19853 {
19854 #if wxUSE_UNICODE
19855 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19856 #else
19857 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19858 #endif
19859 }
19860 return pyobj;
19861 }
19862
19863
19864 SWIGINTERN int ART_TIP_set(PyObject *) {
19865 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19866 return 1;
19867 }
19868
19869
19870 SWIGINTERN PyObject *ART_TIP_get(void) {
19871 PyObject *pyobj = 0;
19872
19873 {
19874 #if wxUSE_UNICODE
19875 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19876 #else
19877 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19878 #endif
19879 }
19880 return pyobj;
19881 }
19882
19883
19884 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19885 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19886 return 1;
19887 }
19888
19889
19890 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19891 PyObject *pyobj = 0;
19892
19893 {
19894 #if wxUSE_UNICODE
19895 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19896 #else
19897 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19898 #endif
19899 }
19900 return pyobj;
19901 }
19902
19903
19904 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19905 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19906 return 1;
19907 }
19908
19909
19910 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19911 PyObject *pyobj = 0;
19912
19913 {
19914 #if wxUSE_UNICODE
19915 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19916 #else
19917 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19918 #endif
19919 }
19920 return pyobj;
19921 }
19922
19923
19924 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19925 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19926 return 1;
19927 }
19928
19929
19930 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19931 PyObject *pyobj = 0;
19932
19933 {
19934 #if wxUSE_UNICODE
19935 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19936 #else
19937 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19938 #endif
19939 }
19940 return pyobj;
19941 }
19942
19943
19944 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19945 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19946 return 1;
19947 }
19948
19949
19950 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19951 PyObject *pyobj = 0;
19952
19953 {
19954 #if wxUSE_UNICODE
19955 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19956 #else
19957 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19958 #endif
19959 }
19960 return pyobj;
19961 }
19962
19963
19964 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19965 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19966 return 1;
19967 }
19968
19969
19970 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19971 PyObject *pyobj = 0;
19972
19973 {
19974 #if wxUSE_UNICODE
19975 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19976 #else
19977 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19978 #endif
19979 }
19980 return pyobj;
19981 }
19982
19983
19984 SWIGINTERN int ART_CDROM_set(PyObject *) {
19985 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19986 return 1;
19987 }
19988
19989
19990 SWIGINTERN PyObject *ART_CDROM_get(void) {
19991 PyObject *pyobj = 0;
19992
19993 {
19994 #if wxUSE_UNICODE
19995 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19996 #else
19997 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19998 #endif
19999 }
20000 return pyobj;
20001 }
20002
20003
20004 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
20005 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
20006 return 1;
20007 }
20008
20009
20010 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
20011 PyObject *pyobj = 0;
20012
20013 {
20014 #if wxUSE_UNICODE
20015 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20016 #else
20017 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20018 #endif
20019 }
20020 return pyobj;
20021 }
20022
20023
20024 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20025 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20026 return 1;
20027 }
20028
20029
20030 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20031 PyObject *pyobj = 0;
20032
20033 {
20034 #if wxUSE_UNICODE
20035 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20036 #else
20037 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20038 #endif
20039 }
20040 return pyobj;
20041 }
20042
20043
20044 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20045 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20046 return 1;
20047 }
20048
20049
20050 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20051 PyObject *pyobj = 0;
20052
20053 {
20054 #if wxUSE_UNICODE
20055 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20056 #else
20057 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20058 #endif
20059 }
20060 return pyobj;
20061 }
20062
20063
20064 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20065 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20066 return 1;
20067 }
20068
20069
20070 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20071 PyObject *pyobj = 0;
20072
20073 {
20074 #if wxUSE_UNICODE
20075 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20076 #else
20077 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20078 #endif
20079 }
20080 return pyobj;
20081 }
20082
20083
20084 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20085 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20086 return 1;
20087 }
20088
20089
20090 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20091 PyObject *pyobj = 0;
20092
20093 {
20094 #if wxUSE_UNICODE
20095 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20096 #else
20097 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20098 #endif
20099 }
20100 return pyobj;
20101 }
20102
20103
20104 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20105 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20106 return 1;
20107 }
20108
20109
20110 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20111 PyObject *pyobj = 0;
20112
20113 {
20114 #if wxUSE_UNICODE
20115 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20116 #else
20117 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20118 #endif
20119 }
20120 return pyobj;
20121 }
20122
20123
20124 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20125 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20126 return 1;
20127 }
20128
20129
20130 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20131 PyObject *pyobj = 0;
20132
20133 {
20134 #if wxUSE_UNICODE
20135 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20136 #else
20137 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20138 #endif
20139 }
20140 return pyobj;
20141 }
20142
20143
20144 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20145 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20146 return 1;
20147 }
20148
20149
20150 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20151 PyObject *pyobj = 0;
20152
20153 {
20154 #if wxUSE_UNICODE
20155 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20156 #else
20157 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20158 #endif
20159 }
20160 return pyobj;
20161 }
20162
20163
20164 SWIGINTERN int ART_ERROR_set(PyObject *) {
20165 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20166 return 1;
20167 }
20168
20169
20170 SWIGINTERN PyObject *ART_ERROR_get(void) {
20171 PyObject *pyobj = 0;
20172
20173 {
20174 #if wxUSE_UNICODE
20175 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20176 #else
20177 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20178 #endif
20179 }
20180 return pyobj;
20181 }
20182
20183
20184 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20185 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20186 return 1;
20187 }
20188
20189
20190 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20191 PyObject *pyobj = 0;
20192
20193 {
20194 #if wxUSE_UNICODE
20195 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20196 #else
20197 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20198 #endif
20199 }
20200 return pyobj;
20201 }
20202
20203
20204 SWIGINTERN int ART_WARNING_set(PyObject *) {
20205 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20206 return 1;
20207 }
20208
20209
20210 SWIGINTERN PyObject *ART_WARNING_get(void) {
20211 PyObject *pyobj = 0;
20212
20213 {
20214 #if wxUSE_UNICODE
20215 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20216 #else
20217 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20218 #endif
20219 }
20220 return pyobj;
20221 }
20222
20223
20224 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20225 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20226 return 1;
20227 }
20228
20229
20230 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20231 PyObject *pyobj = 0;
20232
20233 {
20234 #if wxUSE_UNICODE
20235 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20236 #else
20237 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20238 #endif
20239 }
20240 return pyobj;
20241 }
20242
20243
20244 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20245 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20246 return 1;
20247 }
20248
20249
20250 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20251 PyObject *pyobj = 0;
20252
20253 {
20254 #if wxUSE_UNICODE
20255 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20256 #else
20257 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20258 #endif
20259 }
20260 return pyobj;
20261 }
20262
20263
20264 SWIGINTERN int ART_COPY_set(PyObject *) {
20265 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20266 return 1;
20267 }
20268
20269
20270 SWIGINTERN PyObject *ART_COPY_get(void) {
20271 PyObject *pyobj = 0;
20272
20273 {
20274 #if wxUSE_UNICODE
20275 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20276 #else
20277 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20278 #endif
20279 }
20280 return pyobj;
20281 }
20282
20283
20284 SWIGINTERN int ART_CUT_set(PyObject *) {
20285 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20286 return 1;
20287 }
20288
20289
20290 SWIGINTERN PyObject *ART_CUT_get(void) {
20291 PyObject *pyobj = 0;
20292
20293 {
20294 #if wxUSE_UNICODE
20295 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20296 #else
20297 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20298 #endif
20299 }
20300 return pyobj;
20301 }
20302
20303
20304 SWIGINTERN int ART_PASTE_set(PyObject *) {
20305 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20306 return 1;
20307 }
20308
20309
20310 SWIGINTERN PyObject *ART_PASTE_get(void) {
20311 PyObject *pyobj = 0;
20312
20313 {
20314 #if wxUSE_UNICODE
20315 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20316 #else
20317 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20318 #endif
20319 }
20320 return pyobj;
20321 }
20322
20323
20324 SWIGINTERN int ART_DELETE_set(PyObject *) {
20325 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20326 return 1;
20327 }
20328
20329
20330 SWIGINTERN PyObject *ART_DELETE_get(void) {
20331 PyObject *pyobj = 0;
20332
20333 {
20334 #if wxUSE_UNICODE
20335 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20336 #else
20337 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20338 #endif
20339 }
20340 return pyobj;
20341 }
20342
20343
20344 SWIGINTERN int ART_NEW_set(PyObject *) {
20345 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20346 return 1;
20347 }
20348
20349
20350 SWIGINTERN PyObject *ART_NEW_get(void) {
20351 PyObject *pyobj = 0;
20352
20353 {
20354 #if wxUSE_UNICODE
20355 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20356 #else
20357 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20358 #endif
20359 }
20360 return pyobj;
20361 }
20362
20363
20364 SWIGINTERN int ART_UNDO_set(PyObject *) {
20365 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20366 return 1;
20367 }
20368
20369
20370 SWIGINTERN PyObject *ART_UNDO_get(void) {
20371 PyObject *pyobj = 0;
20372
20373 {
20374 #if wxUSE_UNICODE
20375 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20376 #else
20377 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20378 #endif
20379 }
20380 return pyobj;
20381 }
20382
20383
20384 SWIGINTERN int ART_REDO_set(PyObject *) {
20385 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20386 return 1;
20387 }
20388
20389
20390 SWIGINTERN PyObject *ART_REDO_get(void) {
20391 PyObject *pyobj = 0;
20392
20393 {
20394 #if wxUSE_UNICODE
20395 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20396 #else
20397 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20398 #endif
20399 }
20400 return pyobj;
20401 }
20402
20403
20404 SWIGINTERN int ART_QUIT_set(PyObject *) {
20405 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20406 return 1;
20407 }
20408
20409
20410 SWIGINTERN PyObject *ART_QUIT_get(void) {
20411 PyObject *pyobj = 0;
20412
20413 {
20414 #if wxUSE_UNICODE
20415 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20416 #else
20417 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20418 #endif
20419 }
20420 return pyobj;
20421 }
20422
20423
20424 SWIGINTERN int ART_FIND_set(PyObject *) {
20425 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20426 return 1;
20427 }
20428
20429
20430 SWIGINTERN PyObject *ART_FIND_get(void) {
20431 PyObject *pyobj = 0;
20432
20433 {
20434 #if wxUSE_UNICODE
20435 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20436 #else
20437 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20438 #endif
20439 }
20440 return pyobj;
20441 }
20442
20443
20444 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20445 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20446 return 1;
20447 }
20448
20449
20450 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20451 PyObject *pyobj = 0;
20452
20453 {
20454 #if wxUSE_UNICODE
20455 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20456 #else
20457 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20458 #endif
20459 }
20460 return pyobj;
20461 }
20462
20463
20464 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20465 PyObject *resultobj = 0;
20466 wxPyArtProvider *result = 0 ;
20467
20468 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20469 {
20470 if (!wxPyCheckForApp()) SWIG_fail;
20471 PyThreadState* __tstate = wxPyBeginAllowThreads();
20472 result = (wxPyArtProvider *)new wxPyArtProvider();
20473 wxPyEndAllowThreads(__tstate);
20474 if (PyErr_Occurred()) SWIG_fail;
20475 }
20476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20484 PyObject *resultobj = 0;
20485 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20486 void *argp1 = 0 ;
20487 int res1 = 0 ;
20488 PyObject *swig_obj[1] ;
20489
20490 if (!args) SWIG_fail;
20491 swig_obj[0] = args;
20492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20493 if (!SWIG_IsOK(res1)) {
20494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20495 }
20496 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 delete arg1;
20500
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 resultobj = SWIG_Py_Void();
20505 return resultobj;
20506 fail:
20507 return NULL;
20508 }
20509
20510
20511 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20512 PyObject *resultobj = 0;
20513 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20514 PyObject *arg2 = (PyObject *) 0 ;
20515 PyObject *arg3 = (PyObject *) 0 ;
20516 void *argp1 = 0 ;
20517 int res1 = 0 ;
20518 PyObject * obj0 = 0 ;
20519 PyObject * obj1 = 0 ;
20520 PyObject * obj2 = 0 ;
20521 char * kwnames[] = {
20522 (char *) "self",(char *) "self",(char *) "_class", NULL
20523 };
20524
20525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20527 if (!SWIG_IsOK(res1)) {
20528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20529 }
20530 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20531 arg2 = obj1;
20532 arg3 = obj2;
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 (arg1)->_setCallbackInfo(arg2,arg3);
20536 wxPyEndAllowThreads(__tstate);
20537 if (PyErr_Occurred()) SWIG_fail;
20538 }
20539 resultobj = SWIG_Py_Void();
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20547 PyObject *resultobj = 0;
20548 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20549 int res1 = 0 ;
20550 PyObject * obj0 = 0 ;
20551 char * kwnames[] = {
20552 (char *) "provider", NULL
20553 };
20554
20555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20556 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20559 }
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 wxPyArtProvider::Push(arg1);
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 resultobj = SWIG_Py_Void();
20567 return resultobj;
20568 fail:
20569 return NULL;
20570 }
20571
20572
20573 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20574 PyObject *resultobj = 0;
20575 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20576 int res1 = 0 ;
20577 PyObject * obj0 = 0 ;
20578 char * kwnames[] = {
20579 (char *) "provider", NULL
20580 };
20581
20582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20583 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20584 if (!SWIG_IsOK(res1)) {
20585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20586 }
20587 {
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 wxPyArtProvider::Insert(arg1);
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 resultobj = SWIG_Py_Void();
20594 return resultobj;
20595 fail:
20596 return NULL;
20597 }
20598
20599
20600 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20601 PyObject *resultobj = 0;
20602 bool result;
20603
20604 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20605 {
20606 PyThreadState* __tstate = wxPyBeginAllowThreads();
20607 result = (bool)wxPyArtProvider::Pop();
20608 wxPyEndAllowThreads(__tstate);
20609 if (PyErr_Occurred()) SWIG_fail;
20610 }
20611 {
20612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20613 }
20614 return resultobj;
20615 fail:
20616 return NULL;
20617 }
20618
20619
20620 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20621 PyObject *resultobj = 0;
20622 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20623 bool result;
20624 void *argp1 = 0 ;
20625 int res1 = 0 ;
20626 PyObject * obj0 = 0 ;
20627 char * kwnames[] = {
20628 (char *) "provider", NULL
20629 };
20630
20631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20633 if (!SWIG_IsOK(res1)) {
20634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20635 }
20636 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20637 {
20638 PyThreadState* __tstate = wxPyBeginAllowThreads();
20639 result = (bool)wxPyArtProvider::Delete(arg1);
20640 wxPyEndAllowThreads(__tstate);
20641 if (PyErr_Occurred()) SWIG_fail;
20642 }
20643 {
20644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20645 }
20646 return resultobj;
20647 fail:
20648 return NULL;
20649 }
20650
20651
20652 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj = 0;
20654 wxString *arg1 = 0 ;
20655 wxString const &arg2_defvalue = wxPyART_OTHER ;
20656 wxString *arg2 = (wxString *) &arg2_defvalue ;
20657 wxSize const &arg3_defvalue = wxDefaultSize ;
20658 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20659 wxBitmap result;
20660 bool temp1 = false ;
20661 bool temp2 = false ;
20662 wxSize temp3 ;
20663 PyObject * obj0 = 0 ;
20664 PyObject * obj1 = 0 ;
20665 PyObject * obj2 = 0 ;
20666 char * kwnames[] = {
20667 (char *) "id",(char *) "client",(char *) "size", NULL
20668 };
20669
20670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20671 {
20672 arg1 = wxString_in_helper(obj0);
20673 if (arg1 == NULL) SWIG_fail;
20674 temp1 = true;
20675 }
20676 if (obj1) {
20677 {
20678 arg2 = wxString_in_helper(obj1);
20679 if (arg2 == NULL) SWIG_fail;
20680 temp2 = true;
20681 }
20682 }
20683 if (obj2) {
20684 {
20685 arg3 = &temp3;
20686 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20687 }
20688 }
20689 {
20690 if (!wxPyCheckForApp()) SWIG_fail;
20691 PyThreadState* __tstate = wxPyBeginAllowThreads();
20692 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20693 wxPyEndAllowThreads(__tstate);
20694 if (PyErr_Occurred()) SWIG_fail;
20695 }
20696 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20697 {
20698 if (temp1)
20699 delete arg1;
20700 }
20701 {
20702 if (temp2)
20703 delete arg2;
20704 }
20705 return resultobj;
20706 fail:
20707 {
20708 if (temp1)
20709 delete arg1;
20710 }
20711 {
20712 if (temp2)
20713 delete arg2;
20714 }
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj = 0;
20721 wxString *arg1 = 0 ;
20722 wxString const &arg2_defvalue = wxPyART_OTHER ;
20723 wxString *arg2 = (wxString *) &arg2_defvalue ;
20724 wxSize const &arg3_defvalue = wxDefaultSize ;
20725 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20726 wxIcon result;
20727 bool temp1 = false ;
20728 bool temp2 = false ;
20729 wxSize temp3 ;
20730 PyObject * obj0 = 0 ;
20731 PyObject * obj1 = 0 ;
20732 PyObject * obj2 = 0 ;
20733 char * kwnames[] = {
20734 (char *) "id",(char *) "client",(char *) "size", NULL
20735 };
20736
20737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20738 {
20739 arg1 = wxString_in_helper(obj0);
20740 if (arg1 == NULL) SWIG_fail;
20741 temp1 = true;
20742 }
20743 if (obj1) {
20744 {
20745 arg2 = wxString_in_helper(obj1);
20746 if (arg2 == NULL) SWIG_fail;
20747 temp2 = true;
20748 }
20749 }
20750 if (obj2) {
20751 {
20752 arg3 = &temp3;
20753 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20754 }
20755 }
20756 {
20757 if (!wxPyCheckForApp()) SWIG_fail;
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20760 wxPyEndAllowThreads(__tstate);
20761 if (PyErr_Occurred()) SWIG_fail;
20762 }
20763 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20764 {
20765 if (temp1)
20766 delete arg1;
20767 }
20768 {
20769 if (temp2)
20770 delete arg2;
20771 }
20772 return resultobj;
20773 fail:
20774 {
20775 if (temp1)
20776 delete arg1;
20777 }
20778 {
20779 if (temp2)
20780 delete arg2;
20781 }
20782 return NULL;
20783 }
20784
20785
20786 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20787 PyObject *resultobj = 0;
20788 wxString *arg1 = 0 ;
20789 bool arg2 = (bool) false ;
20790 wxSize result;
20791 bool temp1 = false ;
20792 bool val2 ;
20793 int ecode2 = 0 ;
20794 PyObject * obj0 = 0 ;
20795 PyObject * obj1 = 0 ;
20796 char * kwnames[] = {
20797 (char *) "client",(char *) "platform_dependent", NULL
20798 };
20799
20800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20801 {
20802 arg1 = wxString_in_helper(obj0);
20803 if (arg1 == NULL) SWIG_fail;
20804 temp1 = true;
20805 }
20806 if (obj1) {
20807 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20808 if (!SWIG_IsOK(ecode2)) {
20809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20810 }
20811 arg2 = static_cast< bool >(val2);
20812 }
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20820 {
20821 if (temp1)
20822 delete arg1;
20823 }
20824 return resultobj;
20825 fail:
20826 {
20827 if (temp1)
20828 delete arg1;
20829 }
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20835 PyObject *resultobj = 0;
20836 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 PyObject *swig_obj[1] ;
20840
20841 if (!args) SWIG_fail;
20842 swig_obj[0] = args;
20843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20844 if (!SWIG_IsOK(res1)) {
20845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20846 }
20847 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 wxPyArtProvider_Destroy(arg1);
20851 wxPyEndAllowThreads(__tstate);
20852 if (PyErr_Occurred()) SWIG_fail;
20853 }
20854 resultobj = SWIG_Py_Void();
20855 return resultobj;
20856 fail:
20857 return NULL;
20858 }
20859
20860
20861 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20862 PyObject *obj;
20863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20864 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20865 return SWIG_Py_Void();
20866 }
20867
20868 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20869 return SWIG_Python_InitShadowInstance(args);
20870 }
20871
20872 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20873 PyObject *resultobj = 0;
20874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20875 void *argp1 = 0 ;
20876 int res1 = 0 ;
20877 PyObject *swig_obj[1] ;
20878
20879 if (!args) SWIG_fail;
20880 swig_obj[0] = args;
20881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20882 if (!SWIG_IsOK(res1)) {
20883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20884 }
20885 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20886 {
20887 PyThreadState* __tstate = wxPyBeginAllowThreads();
20888 delete arg1;
20889
20890 wxPyEndAllowThreads(__tstate);
20891 if (PyErr_Occurred()) SWIG_fail;
20892 }
20893 resultobj = SWIG_Py_Void();
20894 return resultobj;
20895 fail:
20896 return NULL;
20897 }
20898
20899
20900 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20901 PyObject *resultobj = 0;
20902 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20903 wxConfigBase *result = 0 ;
20904 int res1 = 0 ;
20905 PyObject * obj0 = 0 ;
20906 char * kwnames[] = {
20907 (char *) "config", NULL
20908 };
20909
20910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20911 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20912 if (!SWIG_IsOK(res1)) {
20913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20914 }
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20929 PyObject *resultobj = 0;
20930 bool arg1 = (bool) true ;
20931 wxConfigBase *result = 0 ;
20932 bool val1 ;
20933 int ecode1 = 0 ;
20934 PyObject * obj0 = 0 ;
20935 char * kwnames[] = {
20936 (char *) "createOnDemand", NULL
20937 };
20938
20939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20940 if (obj0) {
20941 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20942 if (!SWIG_IsOK(ecode1)) {
20943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20944 }
20945 arg1 = static_cast< bool >(val1);
20946 }
20947 {
20948 PyThreadState* __tstate = wxPyBeginAllowThreads();
20949 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20961 PyObject *resultobj = 0;
20962 wxConfigBase *result = 0 ;
20963
20964 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 result = (wxConfigBase *)wxConfigBase::Create();
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980
20981 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 wxConfigBase::DontCreateOnDemand();
20985 wxPyEndAllowThreads(__tstate);
20986 if (PyErr_Occurred()) SWIG_fail;
20987 }
20988 resultobj = SWIG_Py_Void();
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj = 0;
20997 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20998 wxString *arg2 = 0 ;
20999 void *argp1 = 0 ;
21000 int res1 = 0 ;
21001 bool temp2 = false ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 char * kwnames[] = {
21005 (char *) "self",(char *) "path", NULL
21006 };
21007
21008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
21009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21010 if (!SWIG_IsOK(res1)) {
21011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21012 }
21013 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21014 {
21015 arg2 = wxString_in_helper(obj1);
21016 if (arg2 == NULL) SWIG_fail;
21017 temp2 = true;
21018 }
21019 {
21020 PyThreadState* __tstate = wxPyBeginAllowThreads();
21021 (arg1)->SetPath((wxString const &)*arg2);
21022 wxPyEndAllowThreads(__tstate);
21023 if (PyErr_Occurred()) SWIG_fail;
21024 }
21025 resultobj = SWIG_Py_Void();
21026 {
21027 if (temp2)
21028 delete arg2;
21029 }
21030 return resultobj;
21031 fail:
21032 {
21033 if (temp2)
21034 delete arg2;
21035 }
21036 return NULL;
21037 }
21038
21039
21040 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21041 PyObject *resultobj = 0;
21042 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21043 wxString *result = 0 ;
21044 void *argp1 = 0 ;
21045 int res1 = 0 ;
21046 PyObject *swig_obj[1] ;
21047
21048 if (!args) SWIG_fail;
21049 swig_obj[0] = args;
21050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21051 if (!SWIG_IsOK(res1)) {
21052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21053 }
21054 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21055 {
21056 PyThreadState* __tstate = wxPyBeginAllowThreads();
21057 {
21058 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21059 result = (wxString *) &_result_ref;
21060 }
21061 wxPyEndAllowThreads(__tstate);
21062 if (PyErr_Occurred()) SWIG_fail;
21063 }
21064 {
21065 #if wxUSE_UNICODE
21066 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21067 #else
21068 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21069 #endif
21070 }
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21078 PyObject *resultobj = 0;
21079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21080 PyObject *result = 0 ;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 PyObject *swig_obj[1] ;
21084
21085 if (!args) SWIG_fail;
21086 swig_obj[0] = args;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21090 }
21091 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21092 {
21093 PyThreadState* __tstate = wxPyBeginAllowThreads();
21094 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21095 wxPyEndAllowThreads(__tstate);
21096 if (PyErr_Occurred()) SWIG_fail;
21097 }
21098 resultobj = result;
21099 return resultobj;
21100 fail:
21101 return NULL;
21102 }
21103
21104
21105 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21106 PyObject *resultobj = 0;
21107 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21108 long arg2 ;
21109 PyObject *result = 0 ;
21110 void *argp1 = 0 ;
21111 int res1 = 0 ;
21112 long val2 ;
21113 int ecode2 = 0 ;
21114 PyObject * obj0 = 0 ;
21115 PyObject * obj1 = 0 ;
21116 char * kwnames[] = {
21117 (char *) "self",(char *) "index", NULL
21118 };
21119
21120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21122 if (!SWIG_IsOK(res1)) {
21123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21124 }
21125 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21126 ecode2 = SWIG_AsVal_long(obj1, &val2);
21127 if (!SWIG_IsOK(ecode2)) {
21128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21129 }
21130 arg2 = static_cast< long >(val2);
21131 {
21132 PyThreadState* __tstate = wxPyBeginAllowThreads();
21133 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 resultobj = result;
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21145 PyObject *resultobj = 0;
21146 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21147 PyObject *result = 0 ;
21148 void *argp1 = 0 ;
21149 int res1 = 0 ;
21150 PyObject *swig_obj[1] ;
21151
21152 if (!args) SWIG_fail;
21153 swig_obj[0] = args;
21154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21155 if (!SWIG_IsOK(res1)) {
21156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21157 }
21158 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21162 wxPyEndAllowThreads(__tstate);
21163 if (PyErr_Occurred()) SWIG_fail;
21164 }
21165 resultobj = result;
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21173 PyObject *resultobj = 0;
21174 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21175 long arg2 ;
21176 PyObject *result = 0 ;
21177 void *argp1 = 0 ;
21178 int res1 = 0 ;
21179 long val2 ;
21180 int ecode2 = 0 ;
21181 PyObject * obj0 = 0 ;
21182 PyObject * obj1 = 0 ;
21183 char * kwnames[] = {
21184 (char *) "self",(char *) "index", NULL
21185 };
21186
21187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21189 if (!SWIG_IsOK(res1)) {
21190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21191 }
21192 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21193 ecode2 = SWIG_AsVal_long(obj1, &val2);
21194 if (!SWIG_IsOK(ecode2)) {
21195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21196 }
21197 arg2 = static_cast< long >(val2);
21198 {
21199 PyThreadState* __tstate = wxPyBeginAllowThreads();
21200 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21201 wxPyEndAllowThreads(__tstate);
21202 if (PyErr_Occurred()) SWIG_fail;
21203 }
21204 resultobj = result;
21205 return resultobj;
21206 fail:
21207 return NULL;
21208 }
21209
21210
21211 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21212 PyObject *resultobj = 0;
21213 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21214 bool arg2 = (bool) false ;
21215 size_t result;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 bool val2 ;
21219 int ecode2 = 0 ;
21220 PyObject * obj0 = 0 ;
21221 PyObject * obj1 = 0 ;
21222 char * kwnames[] = {
21223 (char *) "self",(char *) "recursive", NULL
21224 };
21225
21226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21228 if (!SWIG_IsOK(res1)) {
21229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21230 }
21231 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21232 if (obj1) {
21233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21234 if (!SWIG_IsOK(ecode2)) {
21235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21236 }
21237 arg2 = static_cast< bool >(val2);
21238 }
21239 {
21240 PyThreadState* __tstate = wxPyBeginAllowThreads();
21241 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21242 wxPyEndAllowThreads(__tstate);
21243 if (PyErr_Occurred()) SWIG_fail;
21244 }
21245 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21246 return resultobj;
21247 fail:
21248 return NULL;
21249 }
21250
21251
21252 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21253 PyObject *resultobj = 0;
21254 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21255 bool arg2 = (bool) false ;
21256 size_t result;
21257 void *argp1 = 0 ;
21258 int res1 = 0 ;
21259 bool val2 ;
21260 int ecode2 = 0 ;
21261 PyObject * obj0 = 0 ;
21262 PyObject * obj1 = 0 ;
21263 char * kwnames[] = {
21264 (char *) "self",(char *) "recursive", NULL
21265 };
21266
21267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21271 }
21272 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21273 if (obj1) {
21274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21275 if (!SWIG_IsOK(ecode2)) {
21276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21277 }
21278 arg2 = static_cast< bool >(val2);
21279 }
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21283 wxPyEndAllowThreads(__tstate);
21284 if (PyErr_Occurred()) SWIG_fail;
21285 }
21286 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21294 PyObject *resultobj = 0;
21295 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21296 wxString *arg2 = 0 ;
21297 bool result;
21298 void *argp1 = 0 ;
21299 int res1 = 0 ;
21300 bool temp2 = false ;
21301 PyObject * obj0 = 0 ;
21302 PyObject * obj1 = 0 ;
21303 char * kwnames[] = {
21304 (char *) "self",(char *) "name", NULL
21305 };
21306
21307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21311 }
21312 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21313 {
21314 arg2 = wxString_in_helper(obj1);
21315 if (arg2 == NULL) SWIG_fail;
21316 temp2 = true;
21317 }
21318 {
21319 PyThreadState* __tstate = wxPyBeginAllowThreads();
21320 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21321 wxPyEndAllowThreads(__tstate);
21322 if (PyErr_Occurred()) SWIG_fail;
21323 }
21324 {
21325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21326 }
21327 {
21328 if (temp2)
21329 delete arg2;
21330 }
21331 return resultobj;
21332 fail:
21333 {
21334 if (temp2)
21335 delete arg2;
21336 }
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21342 PyObject *resultobj = 0;
21343 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21344 wxString *arg2 = 0 ;
21345 bool result;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 bool temp2 = false ;
21349 PyObject * obj0 = 0 ;
21350 PyObject * obj1 = 0 ;
21351 char * kwnames[] = {
21352 (char *) "self",(char *) "name", NULL
21353 };
21354
21355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21357 if (!SWIG_IsOK(res1)) {
21358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21359 }
21360 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21361 {
21362 arg2 = wxString_in_helper(obj1);
21363 if (arg2 == NULL) SWIG_fail;
21364 temp2 = true;
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 {
21373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21374 }
21375 {
21376 if (temp2)
21377 delete arg2;
21378 }
21379 return resultobj;
21380 fail:
21381 {
21382 if (temp2)
21383 delete arg2;
21384 }
21385 return NULL;
21386 }
21387
21388
21389 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj = 0;
21391 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21392 wxString *arg2 = 0 ;
21393 bool result;
21394 void *argp1 = 0 ;
21395 int res1 = 0 ;
21396 bool temp2 = false ;
21397 PyObject * obj0 = 0 ;
21398 PyObject * obj1 = 0 ;
21399 char * kwnames[] = {
21400 (char *) "self",(char *) "name", NULL
21401 };
21402
21403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21405 if (!SWIG_IsOK(res1)) {
21406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21407 }
21408 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21409 {
21410 arg2 = wxString_in_helper(obj1);
21411 if (arg2 == NULL) SWIG_fail;
21412 temp2 = true;
21413 }
21414 {
21415 PyThreadState* __tstate = wxPyBeginAllowThreads();
21416 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 {
21421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21422 }
21423 {
21424 if (temp2)
21425 delete arg2;
21426 }
21427 return resultobj;
21428 fail:
21429 {
21430 if (temp2)
21431 delete arg2;
21432 }
21433 return NULL;
21434 }
21435
21436
21437 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21438 PyObject *resultobj = 0;
21439 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21440 wxString *arg2 = 0 ;
21441 wxConfigBase::EntryType result;
21442 void *argp1 = 0 ;
21443 int res1 = 0 ;
21444 bool temp2 = false ;
21445 PyObject * obj0 = 0 ;
21446 PyObject * obj1 = 0 ;
21447 char * kwnames[] = {
21448 (char *) "self",(char *) "name", NULL
21449 };
21450
21451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21453 if (!SWIG_IsOK(res1)) {
21454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21455 }
21456 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21457 {
21458 arg2 = wxString_in_helper(obj1);
21459 if (arg2 == NULL) SWIG_fail;
21460 temp2 = true;
21461 }
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 resultobj = SWIG_From_int(static_cast< int >(result));
21469 {
21470 if (temp2)
21471 delete arg2;
21472 }
21473 return resultobj;
21474 fail:
21475 {
21476 if (temp2)
21477 delete arg2;
21478 }
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21484 PyObject *resultobj = 0;
21485 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21486 wxString *arg2 = 0 ;
21487 wxString const &arg3_defvalue = wxPyEmptyString ;
21488 wxString *arg3 = (wxString *) &arg3_defvalue ;
21489 wxString result;
21490 void *argp1 = 0 ;
21491 int res1 = 0 ;
21492 bool temp2 = false ;
21493 bool temp3 = false ;
21494 PyObject * obj0 = 0 ;
21495 PyObject * obj1 = 0 ;
21496 PyObject * obj2 = 0 ;
21497 char * kwnames[] = {
21498 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21499 };
21500
21501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21503 if (!SWIG_IsOK(res1)) {
21504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21505 }
21506 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21507 {
21508 arg2 = wxString_in_helper(obj1);
21509 if (arg2 == NULL) SWIG_fail;
21510 temp2 = true;
21511 }
21512 if (obj2) {
21513 {
21514 arg3 = wxString_in_helper(obj2);
21515 if (arg3 == NULL) SWIG_fail;
21516 temp3 = true;
21517 }
21518 }
21519 {
21520 PyThreadState* __tstate = wxPyBeginAllowThreads();
21521 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 {
21526 #if wxUSE_UNICODE
21527 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21528 #else
21529 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21530 #endif
21531 }
21532 {
21533 if (temp2)
21534 delete arg2;
21535 }
21536 {
21537 if (temp3)
21538 delete arg3;
21539 }
21540 return resultobj;
21541 fail:
21542 {
21543 if (temp2)
21544 delete arg2;
21545 }
21546 {
21547 if (temp3)
21548 delete arg3;
21549 }
21550 return NULL;
21551 }
21552
21553
21554 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21555 PyObject *resultobj = 0;
21556 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21557 wxString *arg2 = 0 ;
21558 long arg3 = (long) 0 ;
21559 long result;
21560 void *argp1 = 0 ;
21561 int res1 = 0 ;
21562 bool temp2 = false ;
21563 long val3 ;
21564 int ecode3 = 0 ;
21565 PyObject * obj0 = 0 ;
21566 PyObject * obj1 = 0 ;
21567 PyObject * obj2 = 0 ;
21568 char * kwnames[] = {
21569 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21570 };
21571
21572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21574 if (!SWIG_IsOK(res1)) {
21575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21576 }
21577 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21578 {
21579 arg2 = wxString_in_helper(obj1);
21580 if (arg2 == NULL) SWIG_fail;
21581 temp2 = true;
21582 }
21583 if (obj2) {
21584 ecode3 = SWIG_AsVal_long(obj2, &val3);
21585 if (!SWIG_IsOK(ecode3)) {
21586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21587 }
21588 arg3 = static_cast< long >(val3);
21589 }
21590 {
21591 PyThreadState* __tstate = wxPyBeginAllowThreads();
21592 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21593 wxPyEndAllowThreads(__tstate);
21594 if (PyErr_Occurred()) SWIG_fail;
21595 }
21596 resultobj = SWIG_From_long(static_cast< long >(result));
21597 {
21598 if (temp2)
21599 delete arg2;
21600 }
21601 return resultobj;
21602 fail:
21603 {
21604 if (temp2)
21605 delete arg2;
21606 }
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21612 PyObject *resultobj = 0;
21613 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21614 wxString *arg2 = 0 ;
21615 double arg3 = (double) 0.0 ;
21616 double result;
21617 void *argp1 = 0 ;
21618 int res1 = 0 ;
21619 bool temp2 = false ;
21620 double val3 ;
21621 int ecode3 = 0 ;
21622 PyObject * obj0 = 0 ;
21623 PyObject * obj1 = 0 ;
21624 PyObject * obj2 = 0 ;
21625 char * kwnames[] = {
21626 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21627 };
21628
21629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21631 if (!SWIG_IsOK(res1)) {
21632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21633 }
21634 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21635 {
21636 arg2 = wxString_in_helper(obj1);
21637 if (arg2 == NULL) SWIG_fail;
21638 temp2 = true;
21639 }
21640 if (obj2) {
21641 ecode3 = SWIG_AsVal_double(obj2, &val3);
21642 if (!SWIG_IsOK(ecode3)) {
21643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21644 }
21645 arg3 = static_cast< double >(val3);
21646 }
21647 {
21648 PyThreadState* __tstate = wxPyBeginAllowThreads();
21649 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21650 wxPyEndAllowThreads(__tstate);
21651 if (PyErr_Occurred()) SWIG_fail;
21652 }
21653 resultobj = SWIG_From_double(static_cast< double >(result));
21654 {
21655 if (temp2)
21656 delete arg2;
21657 }
21658 return resultobj;
21659 fail:
21660 {
21661 if (temp2)
21662 delete arg2;
21663 }
21664 return NULL;
21665 }
21666
21667
21668 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21669 PyObject *resultobj = 0;
21670 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21671 wxString *arg2 = 0 ;
21672 bool arg3 = (bool) false ;
21673 bool result;
21674 void *argp1 = 0 ;
21675 int res1 = 0 ;
21676 bool temp2 = false ;
21677 bool val3 ;
21678 int ecode3 = 0 ;
21679 PyObject * obj0 = 0 ;
21680 PyObject * obj1 = 0 ;
21681 PyObject * obj2 = 0 ;
21682 char * kwnames[] = {
21683 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21684 };
21685
21686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21688 if (!SWIG_IsOK(res1)) {
21689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21690 }
21691 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21692 {
21693 arg2 = wxString_in_helper(obj1);
21694 if (arg2 == NULL) SWIG_fail;
21695 temp2 = true;
21696 }
21697 if (obj2) {
21698 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21699 if (!SWIG_IsOK(ecode3)) {
21700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21701 }
21702 arg3 = static_cast< bool >(val3);
21703 }
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 {
21711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21712 }
21713 {
21714 if (temp2)
21715 delete arg2;
21716 }
21717 return resultobj;
21718 fail:
21719 {
21720 if (temp2)
21721 delete arg2;
21722 }
21723 return NULL;
21724 }
21725
21726
21727 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21728 PyObject *resultobj = 0;
21729 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21730 wxString *arg2 = 0 ;
21731 wxString *arg3 = 0 ;
21732 bool result;
21733 void *argp1 = 0 ;
21734 int res1 = 0 ;
21735 bool temp2 = false ;
21736 bool temp3 = false ;
21737 PyObject * obj0 = 0 ;
21738 PyObject * obj1 = 0 ;
21739 PyObject * obj2 = 0 ;
21740 char * kwnames[] = {
21741 (char *) "self",(char *) "key",(char *) "value", NULL
21742 };
21743
21744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21746 if (!SWIG_IsOK(res1)) {
21747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21748 }
21749 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21750 {
21751 arg2 = wxString_in_helper(obj1);
21752 if (arg2 == NULL) SWIG_fail;
21753 temp2 = true;
21754 }
21755 {
21756 arg3 = wxString_in_helper(obj2);
21757 if (arg3 == NULL) SWIG_fail;
21758 temp3 = true;
21759 }
21760 {
21761 PyThreadState* __tstate = wxPyBeginAllowThreads();
21762 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 {
21767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21768 }
21769 {
21770 if (temp2)
21771 delete arg2;
21772 }
21773 {
21774 if (temp3)
21775 delete arg3;
21776 }
21777 return resultobj;
21778 fail:
21779 {
21780 if (temp2)
21781 delete arg2;
21782 }
21783 {
21784 if (temp3)
21785 delete arg3;
21786 }
21787 return NULL;
21788 }
21789
21790
21791 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21792 PyObject *resultobj = 0;
21793 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21794 wxString *arg2 = 0 ;
21795 long arg3 ;
21796 bool result;
21797 void *argp1 = 0 ;
21798 int res1 = 0 ;
21799 bool temp2 = false ;
21800 long val3 ;
21801 int ecode3 = 0 ;
21802 PyObject * obj0 = 0 ;
21803 PyObject * obj1 = 0 ;
21804 PyObject * obj2 = 0 ;
21805 char * kwnames[] = {
21806 (char *) "self",(char *) "key",(char *) "value", NULL
21807 };
21808
21809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21811 if (!SWIG_IsOK(res1)) {
21812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21813 }
21814 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21815 {
21816 arg2 = wxString_in_helper(obj1);
21817 if (arg2 == NULL) SWIG_fail;
21818 temp2 = true;
21819 }
21820 ecode3 = SWIG_AsVal_long(obj2, &val3);
21821 if (!SWIG_IsOK(ecode3)) {
21822 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21823 }
21824 arg3 = static_cast< long >(val3);
21825 {
21826 PyThreadState* __tstate = wxPyBeginAllowThreads();
21827 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21828 wxPyEndAllowThreads(__tstate);
21829 if (PyErr_Occurred()) SWIG_fail;
21830 }
21831 {
21832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21833 }
21834 {
21835 if (temp2)
21836 delete arg2;
21837 }
21838 return resultobj;
21839 fail:
21840 {
21841 if (temp2)
21842 delete arg2;
21843 }
21844 return NULL;
21845 }
21846
21847
21848 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21849 PyObject *resultobj = 0;
21850 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21851 wxString *arg2 = 0 ;
21852 double arg3 ;
21853 bool result;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 bool temp2 = false ;
21857 double val3 ;
21858 int ecode3 = 0 ;
21859 PyObject * obj0 = 0 ;
21860 PyObject * obj1 = 0 ;
21861 PyObject * obj2 = 0 ;
21862 char * kwnames[] = {
21863 (char *) "self",(char *) "key",(char *) "value", NULL
21864 };
21865
21866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21868 if (!SWIG_IsOK(res1)) {
21869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21870 }
21871 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21872 {
21873 arg2 = wxString_in_helper(obj1);
21874 if (arg2 == NULL) SWIG_fail;
21875 temp2 = true;
21876 }
21877 ecode3 = SWIG_AsVal_double(obj2, &val3);
21878 if (!SWIG_IsOK(ecode3)) {
21879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21880 }
21881 arg3 = static_cast< double >(val3);
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 {
21889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21890 }
21891 {
21892 if (temp2)
21893 delete arg2;
21894 }
21895 return resultobj;
21896 fail:
21897 {
21898 if (temp2)
21899 delete arg2;
21900 }
21901 return NULL;
21902 }
21903
21904
21905 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21906 PyObject *resultobj = 0;
21907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21908 wxString *arg2 = 0 ;
21909 bool arg3 ;
21910 bool result;
21911 void *argp1 = 0 ;
21912 int res1 = 0 ;
21913 bool temp2 = false ;
21914 bool val3 ;
21915 int ecode3 = 0 ;
21916 PyObject * obj0 = 0 ;
21917 PyObject * obj1 = 0 ;
21918 PyObject * obj2 = 0 ;
21919 char * kwnames[] = {
21920 (char *) "self",(char *) "key",(char *) "value", NULL
21921 };
21922
21923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21925 if (!SWIG_IsOK(res1)) {
21926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21927 }
21928 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21929 {
21930 arg2 = wxString_in_helper(obj1);
21931 if (arg2 == NULL) SWIG_fail;
21932 temp2 = true;
21933 }
21934 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21935 if (!SWIG_IsOK(ecode3)) {
21936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21937 }
21938 arg3 = static_cast< bool >(val3);
21939 {
21940 PyThreadState* __tstate = wxPyBeginAllowThreads();
21941 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21942 wxPyEndAllowThreads(__tstate);
21943 if (PyErr_Occurred()) SWIG_fail;
21944 }
21945 {
21946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21947 }
21948 {
21949 if (temp2)
21950 delete arg2;
21951 }
21952 return resultobj;
21953 fail:
21954 {
21955 if (temp2)
21956 delete arg2;
21957 }
21958 return NULL;
21959 }
21960
21961
21962 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj = 0;
21964 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21965 bool arg2 = (bool) false ;
21966 bool result;
21967 void *argp1 = 0 ;
21968 int res1 = 0 ;
21969 bool val2 ;
21970 int ecode2 = 0 ;
21971 PyObject * obj0 = 0 ;
21972 PyObject * obj1 = 0 ;
21973 char * kwnames[] = {
21974 (char *) "self",(char *) "currentOnly", NULL
21975 };
21976
21977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21979 if (!SWIG_IsOK(res1)) {
21980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21981 }
21982 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21983 if (obj1) {
21984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21985 if (!SWIG_IsOK(ecode2)) {
21986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21987 }
21988 arg2 = static_cast< bool >(val2);
21989 }
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 result = (bool)(arg1)->Flush(arg2);
21993 wxPyEndAllowThreads(__tstate);
21994 if (PyErr_Occurred()) SWIG_fail;
21995 }
21996 {
21997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21998 }
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22006 PyObject *resultobj = 0;
22007 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22008 wxString *arg2 = 0 ;
22009 wxString *arg3 = 0 ;
22010 bool result;
22011 void *argp1 = 0 ;
22012 int res1 = 0 ;
22013 bool temp2 = false ;
22014 bool temp3 = false ;
22015 PyObject * obj0 = 0 ;
22016 PyObject * obj1 = 0 ;
22017 PyObject * obj2 = 0 ;
22018 char * kwnames[] = {
22019 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22020 };
22021
22022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22024 if (!SWIG_IsOK(res1)) {
22025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22026 }
22027 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22028 {
22029 arg2 = wxString_in_helper(obj1);
22030 if (arg2 == NULL) SWIG_fail;
22031 temp2 = true;
22032 }
22033 {
22034 arg3 = wxString_in_helper(obj2);
22035 if (arg3 == NULL) SWIG_fail;
22036 temp3 = true;
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22041 wxPyEndAllowThreads(__tstate);
22042 if (PyErr_Occurred()) SWIG_fail;
22043 }
22044 {
22045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22046 }
22047 {
22048 if (temp2)
22049 delete arg2;
22050 }
22051 {
22052 if (temp3)
22053 delete arg3;
22054 }
22055 return resultobj;
22056 fail:
22057 {
22058 if (temp2)
22059 delete arg2;
22060 }
22061 {
22062 if (temp3)
22063 delete arg3;
22064 }
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22070 PyObject *resultobj = 0;
22071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22072 wxString *arg2 = 0 ;
22073 wxString *arg3 = 0 ;
22074 bool result;
22075 void *argp1 = 0 ;
22076 int res1 = 0 ;
22077 bool temp2 = false ;
22078 bool temp3 = false ;
22079 PyObject * obj0 = 0 ;
22080 PyObject * obj1 = 0 ;
22081 PyObject * obj2 = 0 ;
22082 char * kwnames[] = {
22083 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22084 };
22085
22086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22088 if (!SWIG_IsOK(res1)) {
22089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22090 }
22091 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22092 {
22093 arg2 = wxString_in_helper(obj1);
22094 if (arg2 == NULL) SWIG_fail;
22095 temp2 = true;
22096 }
22097 {
22098 arg3 = wxString_in_helper(obj2);
22099 if (arg3 == NULL) SWIG_fail;
22100 temp3 = true;
22101 }
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 {
22109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22110 }
22111 {
22112 if (temp2)
22113 delete arg2;
22114 }
22115 {
22116 if (temp3)
22117 delete arg3;
22118 }
22119 return resultobj;
22120 fail:
22121 {
22122 if (temp2)
22123 delete arg2;
22124 }
22125 {
22126 if (temp3)
22127 delete arg3;
22128 }
22129 return NULL;
22130 }
22131
22132
22133 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22134 PyObject *resultobj = 0;
22135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22136 wxString *arg2 = 0 ;
22137 bool arg3 = (bool) true ;
22138 bool result;
22139 void *argp1 = 0 ;
22140 int res1 = 0 ;
22141 bool temp2 = false ;
22142 bool val3 ;
22143 int ecode3 = 0 ;
22144 PyObject * obj0 = 0 ;
22145 PyObject * obj1 = 0 ;
22146 PyObject * obj2 = 0 ;
22147 char * kwnames[] = {
22148 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22149 };
22150
22151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22153 if (!SWIG_IsOK(res1)) {
22154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22155 }
22156 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22157 {
22158 arg2 = wxString_in_helper(obj1);
22159 if (arg2 == NULL) SWIG_fail;
22160 temp2 = true;
22161 }
22162 if (obj2) {
22163 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22164 if (!SWIG_IsOK(ecode3)) {
22165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22166 }
22167 arg3 = static_cast< bool >(val3);
22168 }
22169 {
22170 PyThreadState* __tstate = wxPyBeginAllowThreads();
22171 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 {
22176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22177 }
22178 {
22179 if (temp2)
22180 delete arg2;
22181 }
22182 return resultobj;
22183 fail:
22184 {
22185 if (temp2)
22186 delete arg2;
22187 }
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj = 0;
22194 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22195 wxString *arg2 = 0 ;
22196 bool result;
22197 void *argp1 = 0 ;
22198 int res1 = 0 ;
22199 bool temp2 = false ;
22200 PyObject * obj0 = 0 ;
22201 PyObject * obj1 = 0 ;
22202 char * kwnames[] = {
22203 (char *) "self",(char *) "key", NULL
22204 };
22205
22206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22208 if (!SWIG_IsOK(res1)) {
22209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22210 }
22211 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22212 {
22213 arg2 = wxString_in_helper(obj1);
22214 if (arg2 == NULL) SWIG_fail;
22215 temp2 = true;
22216 }
22217 {
22218 PyThreadState* __tstate = wxPyBeginAllowThreads();
22219 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22220 wxPyEndAllowThreads(__tstate);
22221 if (PyErr_Occurred()) SWIG_fail;
22222 }
22223 {
22224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22225 }
22226 {
22227 if (temp2)
22228 delete arg2;
22229 }
22230 return resultobj;
22231 fail:
22232 {
22233 if (temp2)
22234 delete arg2;
22235 }
22236 return NULL;
22237 }
22238
22239
22240 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22241 PyObject *resultobj = 0;
22242 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22243 bool result;
22244 void *argp1 = 0 ;
22245 int res1 = 0 ;
22246 PyObject *swig_obj[1] ;
22247
22248 if (!args) SWIG_fail;
22249 swig_obj[0] = args;
22250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22251 if (!SWIG_IsOK(res1)) {
22252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22253 }
22254 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22255 {
22256 PyThreadState* __tstate = wxPyBeginAllowThreads();
22257 result = (bool)(arg1)->DeleteAll();
22258 wxPyEndAllowThreads(__tstate);
22259 if (PyErr_Occurred()) SWIG_fail;
22260 }
22261 {
22262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22263 }
22264 return resultobj;
22265 fail:
22266 return NULL;
22267 }
22268
22269
22270 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22271 PyObject *resultobj = 0;
22272 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22273 bool arg2 = (bool) true ;
22274 void *argp1 = 0 ;
22275 int res1 = 0 ;
22276 bool val2 ;
22277 int ecode2 = 0 ;
22278 PyObject * obj0 = 0 ;
22279 PyObject * obj1 = 0 ;
22280 char * kwnames[] = {
22281 (char *) "self",(char *) "doIt", NULL
22282 };
22283
22284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22286 if (!SWIG_IsOK(res1)) {
22287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22288 }
22289 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22290 if (obj1) {
22291 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22292 if (!SWIG_IsOK(ecode2)) {
22293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22294 }
22295 arg2 = static_cast< bool >(val2);
22296 }
22297 {
22298 PyThreadState* __tstate = wxPyBeginAllowThreads();
22299 (arg1)->SetExpandEnvVars(arg2);
22300 wxPyEndAllowThreads(__tstate);
22301 if (PyErr_Occurred()) SWIG_fail;
22302 }
22303 resultobj = SWIG_Py_Void();
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22311 PyObject *resultobj = 0;
22312 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22313 bool result;
22314 void *argp1 = 0 ;
22315 int res1 = 0 ;
22316 PyObject *swig_obj[1] ;
22317
22318 if (!args) SWIG_fail;
22319 swig_obj[0] = args;
22320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22321 if (!SWIG_IsOK(res1)) {
22322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22323 }
22324 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22325 {
22326 PyThreadState* __tstate = wxPyBeginAllowThreads();
22327 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 {
22332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22333 }
22334 return resultobj;
22335 fail:
22336 return NULL;
22337 }
22338
22339
22340 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22341 PyObject *resultobj = 0;
22342 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22343 bool arg2 = (bool) true ;
22344 void *argp1 = 0 ;
22345 int res1 = 0 ;
22346 bool val2 ;
22347 int ecode2 = 0 ;
22348 PyObject * obj0 = 0 ;
22349 PyObject * obj1 = 0 ;
22350 char * kwnames[] = {
22351 (char *) "self",(char *) "doIt", NULL
22352 };
22353
22354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22356 if (!SWIG_IsOK(res1)) {
22357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22358 }
22359 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22360 if (obj1) {
22361 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22362 if (!SWIG_IsOK(ecode2)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22364 }
22365 arg2 = static_cast< bool >(val2);
22366 }
22367 {
22368 PyThreadState* __tstate = wxPyBeginAllowThreads();
22369 (arg1)->SetRecordDefaults(arg2);
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 resultobj = SWIG_Py_Void();
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22383 bool result;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 PyObject *swig_obj[1] ;
22387
22388 if (!args) SWIG_fail;
22389 swig_obj[0] = args;
22390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22393 }
22394 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22395 {
22396 PyThreadState* __tstate = wxPyBeginAllowThreads();
22397 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22398 wxPyEndAllowThreads(__tstate);
22399 if (PyErr_Occurred()) SWIG_fail;
22400 }
22401 {
22402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22403 }
22404 return resultobj;
22405 fail:
22406 return NULL;
22407 }
22408
22409
22410 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22411 PyObject *resultobj = 0;
22412 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22413 wxString *arg2 = 0 ;
22414 wxString result;
22415 void *argp1 = 0 ;
22416 int res1 = 0 ;
22417 bool temp2 = false ;
22418 PyObject * obj0 = 0 ;
22419 PyObject * obj1 = 0 ;
22420 char * kwnames[] = {
22421 (char *) "self",(char *) "str", NULL
22422 };
22423
22424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22426 if (!SWIG_IsOK(res1)) {
22427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22428 }
22429 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22430 {
22431 arg2 = wxString_in_helper(obj1);
22432 if (arg2 == NULL) SWIG_fail;
22433 temp2 = true;
22434 }
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22438 wxPyEndAllowThreads(__tstate);
22439 if (PyErr_Occurred()) SWIG_fail;
22440 }
22441 {
22442 #if wxUSE_UNICODE
22443 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22444 #else
22445 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22446 #endif
22447 }
22448 {
22449 if (temp2)
22450 delete arg2;
22451 }
22452 return resultobj;
22453 fail:
22454 {
22455 if (temp2)
22456 delete arg2;
22457 }
22458 return NULL;
22459 }
22460
22461
22462 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22463 PyObject *resultobj = 0;
22464 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22465 wxString result;
22466 void *argp1 = 0 ;
22467 int res1 = 0 ;
22468 PyObject *swig_obj[1] ;
22469
22470 if (!args) SWIG_fail;
22471 swig_obj[0] = args;
22472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22473 if (!SWIG_IsOK(res1)) {
22474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22475 }
22476 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22477 {
22478 PyThreadState* __tstate = wxPyBeginAllowThreads();
22479 result = ((wxConfigBase const *)arg1)->GetAppName();
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 {
22484 #if wxUSE_UNICODE
22485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22486 #else
22487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22488 #endif
22489 }
22490 return resultobj;
22491 fail:
22492 return NULL;
22493 }
22494
22495
22496 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22497 PyObject *resultobj = 0;
22498 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22499 wxString result;
22500 void *argp1 = 0 ;
22501 int res1 = 0 ;
22502 PyObject *swig_obj[1] ;
22503
22504 if (!args) SWIG_fail;
22505 swig_obj[0] = args;
22506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22507 if (!SWIG_IsOK(res1)) {
22508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22509 }
22510 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22511 {
22512 PyThreadState* __tstate = wxPyBeginAllowThreads();
22513 result = ((wxConfigBase const *)arg1)->GetVendorName();
22514 wxPyEndAllowThreads(__tstate);
22515 if (PyErr_Occurred()) SWIG_fail;
22516 }
22517 {
22518 #if wxUSE_UNICODE
22519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22520 #else
22521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22522 #endif
22523 }
22524 return resultobj;
22525 fail:
22526 return NULL;
22527 }
22528
22529
22530 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22531 PyObject *resultobj = 0;
22532 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22533 wxString *arg2 = 0 ;
22534 void *argp1 = 0 ;
22535 int res1 = 0 ;
22536 bool temp2 = false ;
22537 PyObject * obj0 = 0 ;
22538 PyObject * obj1 = 0 ;
22539 char * kwnames[] = {
22540 (char *) "self",(char *) "appName", NULL
22541 };
22542
22543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22545 if (!SWIG_IsOK(res1)) {
22546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22547 }
22548 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22549 {
22550 arg2 = wxString_in_helper(obj1);
22551 if (arg2 == NULL) SWIG_fail;
22552 temp2 = true;
22553 }
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 (arg1)->SetAppName((wxString const &)*arg2);
22557 wxPyEndAllowThreads(__tstate);
22558 if (PyErr_Occurred()) SWIG_fail;
22559 }
22560 resultobj = SWIG_Py_Void();
22561 {
22562 if (temp2)
22563 delete arg2;
22564 }
22565 return resultobj;
22566 fail:
22567 {
22568 if (temp2)
22569 delete arg2;
22570 }
22571 return NULL;
22572 }
22573
22574
22575 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22576 PyObject *resultobj = 0;
22577 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22578 wxString *arg2 = 0 ;
22579 void *argp1 = 0 ;
22580 int res1 = 0 ;
22581 bool temp2 = false ;
22582 PyObject * obj0 = 0 ;
22583 PyObject * obj1 = 0 ;
22584 char * kwnames[] = {
22585 (char *) "self",(char *) "vendorName", NULL
22586 };
22587
22588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22592 }
22593 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22594 {
22595 arg2 = wxString_in_helper(obj1);
22596 if (arg2 == NULL) SWIG_fail;
22597 temp2 = true;
22598 }
22599 {
22600 PyThreadState* __tstate = wxPyBeginAllowThreads();
22601 (arg1)->SetVendorName((wxString const &)*arg2);
22602 wxPyEndAllowThreads(__tstate);
22603 if (PyErr_Occurred()) SWIG_fail;
22604 }
22605 resultobj = SWIG_Py_Void();
22606 {
22607 if (temp2)
22608 delete arg2;
22609 }
22610 return resultobj;
22611 fail:
22612 {
22613 if (temp2)
22614 delete arg2;
22615 }
22616 return NULL;
22617 }
22618
22619
22620 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22621 PyObject *resultobj = 0;
22622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22623 long arg2 ;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 long val2 ;
22627 int ecode2 = 0 ;
22628 PyObject * obj0 = 0 ;
22629 PyObject * obj1 = 0 ;
22630 char * kwnames[] = {
22631 (char *) "self",(char *) "style", NULL
22632 };
22633
22634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22638 }
22639 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22640 ecode2 = SWIG_AsVal_long(obj1, &val2);
22641 if (!SWIG_IsOK(ecode2)) {
22642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22643 }
22644 arg2 = static_cast< long >(val2);
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 (arg1)->SetStyle(arg2);
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 resultobj = SWIG_Py_Void();
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22659 PyObject *resultobj = 0;
22660 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22661 long result;
22662 void *argp1 = 0 ;
22663 int res1 = 0 ;
22664 PyObject *swig_obj[1] ;
22665
22666 if (!args) SWIG_fail;
22667 swig_obj[0] = args;
22668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22669 if (!SWIG_IsOK(res1)) {
22670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22671 }
22672 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 resultobj = SWIG_From_long(static_cast< long >(result));
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22687 PyObject *obj;
22688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22689 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22690 return SWIG_Py_Void();
22691 }
22692
22693 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22694 PyObject *resultobj = 0;
22695 wxString const &arg1_defvalue = wxPyEmptyString ;
22696 wxString *arg1 = (wxString *) &arg1_defvalue ;
22697 wxString const &arg2_defvalue = wxPyEmptyString ;
22698 wxString *arg2 = (wxString *) &arg2_defvalue ;
22699 wxString const &arg3_defvalue = wxPyEmptyString ;
22700 wxString *arg3 = (wxString *) &arg3_defvalue ;
22701 wxString const &arg4_defvalue = wxPyEmptyString ;
22702 wxString *arg4 = (wxString *) &arg4_defvalue ;
22703 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22704 wxConfig *result = 0 ;
22705 bool temp1 = false ;
22706 bool temp2 = false ;
22707 bool temp3 = false ;
22708 bool temp4 = false ;
22709 long val5 ;
22710 int ecode5 = 0 ;
22711 PyObject * obj0 = 0 ;
22712 PyObject * obj1 = 0 ;
22713 PyObject * obj2 = 0 ;
22714 PyObject * obj3 = 0 ;
22715 PyObject * obj4 = 0 ;
22716 char * kwnames[] = {
22717 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22718 };
22719
22720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22721 if (obj0) {
22722 {
22723 arg1 = wxString_in_helper(obj0);
22724 if (arg1 == NULL) SWIG_fail;
22725 temp1 = true;
22726 }
22727 }
22728 if (obj1) {
22729 {
22730 arg2 = wxString_in_helper(obj1);
22731 if (arg2 == NULL) SWIG_fail;
22732 temp2 = true;
22733 }
22734 }
22735 if (obj2) {
22736 {
22737 arg3 = wxString_in_helper(obj2);
22738 if (arg3 == NULL) SWIG_fail;
22739 temp3 = true;
22740 }
22741 }
22742 if (obj3) {
22743 {
22744 arg4 = wxString_in_helper(obj3);
22745 if (arg4 == NULL) SWIG_fail;
22746 temp4 = true;
22747 }
22748 }
22749 if (obj4) {
22750 ecode5 = SWIG_AsVal_long(obj4, &val5);
22751 if (!SWIG_IsOK(ecode5)) {
22752 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22753 }
22754 arg5 = static_cast< long >(val5);
22755 }
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22763 {
22764 if (temp1)
22765 delete arg1;
22766 }
22767 {
22768 if (temp2)
22769 delete arg2;
22770 }
22771 {
22772 if (temp3)
22773 delete arg3;
22774 }
22775 {
22776 if (temp4)
22777 delete arg4;
22778 }
22779 return resultobj;
22780 fail:
22781 {
22782 if (temp1)
22783 delete arg1;
22784 }
22785 {
22786 if (temp2)
22787 delete arg2;
22788 }
22789 {
22790 if (temp3)
22791 delete arg3;
22792 }
22793 {
22794 if (temp4)
22795 delete arg4;
22796 }
22797 return NULL;
22798 }
22799
22800
22801 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802 PyObject *resultobj = 0;
22803 wxConfig *arg1 = (wxConfig *) 0 ;
22804 void *argp1 = 0 ;
22805 int res1 = 0 ;
22806 PyObject *swig_obj[1] ;
22807
22808 if (!args) SWIG_fail;
22809 swig_obj[0] = args;
22810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22811 if (!SWIG_IsOK(res1)) {
22812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22813 }
22814 arg1 = reinterpret_cast< wxConfig * >(argp1);
22815 {
22816 PyThreadState* __tstate = wxPyBeginAllowThreads();
22817 delete arg1;
22818
22819 wxPyEndAllowThreads(__tstate);
22820 if (PyErr_Occurred()) SWIG_fail;
22821 }
22822 resultobj = SWIG_Py_Void();
22823 return resultobj;
22824 fail:
22825 return NULL;
22826 }
22827
22828
22829 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22830 PyObject *obj;
22831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22832 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22833 return SWIG_Py_Void();
22834 }
22835
22836 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22837 return SWIG_Python_InitShadowInstance(args);
22838 }
22839
22840 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22841 PyObject *resultobj = 0;
22842 wxString const &arg1_defvalue = wxPyEmptyString ;
22843 wxString *arg1 = (wxString *) &arg1_defvalue ;
22844 wxString const &arg2_defvalue = wxPyEmptyString ;
22845 wxString *arg2 = (wxString *) &arg2_defvalue ;
22846 wxString const &arg3_defvalue = wxPyEmptyString ;
22847 wxString *arg3 = (wxString *) &arg3_defvalue ;
22848 wxString const &arg4_defvalue = wxPyEmptyString ;
22849 wxString *arg4 = (wxString *) &arg4_defvalue ;
22850 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22851 wxFileConfig *result = 0 ;
22852 bool temp1 = false ;
22853 bool temp2 = false ;
22854 bool temp3 = false ;
22855 bool temp4 = false ;
22856 long val5 ;
22857 int ecode5 = 0 ;
22858 PyObject * obj0 = 0 ;
22859 PyObject * obj1 = 0 ;
22860 PyObject * obj2 = 0 ;
22861 PyObject * obj3 = 0 ;
22862 PyObject * obj4 = 0 ;
22863 char * kwnames[] = {
22864 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22865 };
22866
22867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22868 if (obj0) {
22869 {
22870 arg1 = wxString_in_helper(obj0);
22871 if (arg1 == NULL) SWIG_fail;
22872 temp1 = true;
22873 }
22874 }
22875 if (obj1) {
22876 {
22877 arg2 = wxString_in_helper(obj1);
22878 if (arg2 == NULL) SWIG_fail;
22879 temp2 = true;
22880 }
22881 }
22882 if (obj2) {
22883 {
22884 arg3 = wxString_in_helper(obj2);
22885 if (arg3 == NULL) SWIG_fail;
22886 temp3 = true;
22887 }
22888 }
22889 if (obj3) {
22890 {
22891 arg4 = wxString_in_helper(obj3);
22892 if (arg4 == NULL) SWIG_fail;
22893 temp4 = true;
22894 }
22895 }
22896 if (obj4) {
22897 ecode5 = SWIG_AsVal_long(obj4, &val5);
22898 if (!SWIG_IsOK(ecode5)) {
22899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22900 }
22901 arg5 = static_cast< long >(val5);
22902 }
22903 {
22904 PyThreadState* __tstate = wxPyBeginAllowThreads();
22905 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22906 wxPyEndAllowThreads(__tstate);
22907 if (PyErr_Occurred()) SWIG_fail;
22908 }
22909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22910 {
22911 if (temp1)
22912 delete arg1;
22913 }
22914 {
22915 if (temp2)
22916 delete arg2;
22917 }
22918 {
22919 if (temp3)
22920 delete arg3;
22921 }
22922 {
22923 if (temp4)
22924 delete arg4;
22925 }
22926 return resultobj;
22927 fail:
22928 {
22929 if (temp1)
22930 delete arg1;
22931 }
22932 {
22933 if (temp2)
22934 delete arg2;
22935 }
22936 {
22937 if (temp3)
22938 delete arg3;
22939 }
22940 {
22941 if (temp4)
22942 delete arg4;
22943 }
22944 return NULL;
22945 }
22946
22947
22948 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22949 PyObject *resultobj = 0;
22950 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22951 void *argp1 = 0 ;
22952 int res1 = 0 ;
22953 PyObject *swig_obj[1] ;
22954
22955 if (!args) SWIG_fail;
22956 swig_obj[0] = args;
22957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22958 if (!SWIG_IsOK(res1)) {
22959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22960 }
22961 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22962 {
22963 PyThreadState* __tstate = wxPyBeginAllowThreads();
22964 delete arg1;
22965
22966 wxPyEndAllowThreads(__tstate);
22967 if (PyErr_Occurred()) SWIG_fail;
22968 }
22969 resultobj = SWIG_Py_Void();
22970 return resultobj;
22971 fail:
22972 return NULL;
22973 }
22974
22975
22976 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22977 PyObject *obj;
22978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22979 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22980 return SWIG_Py_Void();
22981 }
22982
22983 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22984 return SWIG_Python_InitShadowInstance(args);
22985 }
22986
22987 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22988 PyObject *resultobj = 0;
22989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22990 wxString *arg2 = 0 ;
22991 wxConfigPathChanger *result = 0 ;
22992 void *argp1 = 0 ;
22993 int res1 = 0 ;
22994 bool temp2 = false ;
22995 PyObject * obj0 = 0 ;
22996 PyObject * obj1 = 0 ;
22997 char * kwnames[] = {
22998 (char *) "config",(char *) "entry", NULL
22999 };
23000
23001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
23002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
23003 if (!SWIG_IsOK(res1)) {
23004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
23005 }
23006 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
23007 {
23008 arg2 = wxString_in_helper(obj1);
23009 if (arg2 == NULL) SWIG_fail;
23010 temp2 = true;
23011 }
23012 {
23013 PyThreadState* __tstate = wxPyBeginAllowThreads();
23014 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
23015 wxPyEndAllowThreads(__tstate);
23016 if (PyErr_Occurred()) SWIG_fail;
23017 }
23018 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23019 {
23020 if (temp2)
23021 delete arg2;
23022 }
23023 return resultobj;
23024 fail:
23025 {
23026 if (temp2)
23027 delete arg2;
23028 }
23029 return NULL;
23030 }
23031
23032
23033 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23034 PyObject *resultobj = 0;
23035 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23036 void *argp1 = 0 ;
23037 int res1 = 0 ;
23038 PyObject *swig_obj[1] ;
23039
23040 if (!args) SWIG_fail;
23041 swig_obj[0] = args;
23042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23043 if (!SWIG_IsOK(res1)) {
23044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23045 }
23046 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23047 {
23048 PyThreadState* __tstate = wxPyBeginAllowThreads();
23049 delete arg1;
23050
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 resultobj = SWIG_Py_Void();
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23062 PyObject *resultobj = 0;
23063 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23064 wxString *result = 0 ;
23065 void *argp1 = 0 ;
23066 int res1 = 0 ;
23067 PyObject *swig_obj[1] ;
23068
23069 if (!args) SWIG_fail;
23070 swig_obj[0] = args;
23071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23072 if (!SWIG_IsOK(res1)) {
23073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23074 }
23075 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23076 {
23077 PyThreadState* __tstate = wxPyBeginAllowThreads();
23078 {
23079 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23080 result = (wxString *) &_result_ref;
23081 }
23082 wxPyEndAllowThreads(__tstate);
23083 if (PyErr_Occurred()) SWIG_fail;
23084 }
23085 {
23086 #if wxUSE_UNICODE
23087 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23088 #else
23089 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23090 #endif
23091 }
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23099 PyObject *obj;
23100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23101 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23102 return SWIG_Py_Void();
23103 }
23104
23105 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23106 return SWIG_Python_InitShadowInstance(args);
23107 }
23108
23109 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23110 PyObject *resultobj = 0;
23111 wxString *arg1 = 0 ;
23112 wxString result;
23113 bool temp1 = false ;
23114 PyObject * obj0 = 0 ;
23115 char * kwnames[] = {
23116 (char *) "sz", NULL
23117 };
23118
23119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23120 {
23121 arg1 = wxString_in_helper(obj0);
23122 if (arg1 == NULL) SWIG_fail;
23123 temp1 = true;
23124 }
23125 {
23126 PyThreadState* __tstate = wxPyBeginAllowThreads();
23127 result = wxExpandEnvVars((wxString const &)*arg1);
23128 wxPyEndAllowThreads(__tstate);
23129 if (PyErr_Occurred()) SWIG_fail;
23130 }
23131 {
23132 #if wxUSE_UNICODE
23133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23134 #else
23135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23136 #endif
23137 }
23138 {
23139 if (temp1)
23140 delete arg1;
23141 }
23142 return resultobj;
23143 fail:
23144 {
23145 if (temp1)
23146 delete arg1;
23147 }
23148 return NULL;
23149 }
23150
23151
23152 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23153 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23154 return 1;
23155 }
23156
23157
23158 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23159 PyObject *pyobj = 0;
23160
23161 {
23162 #if wxUSE_UNICODE
23163 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23164 #else
23165 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23166 #endif
23167 }
23168 return pyobj;
23169 }
23170
23171
23172 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23173 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23174 return 1;
23175 }
23176
23177
23178 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23179 PyObject *pyobj = 0;
23180
23181 {
23182 #if wxUSE_UNICODE
23183 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23184 #else
23185 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23186 #endif
23187 }
23188 return pyobj;
23189 }
23190
23191
23192 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23193 PyObject *resultobj = 0;
23194 wxDateTime::Country arg1 ;
23195 int val1 ;
23196 int ecode1 = 0 ;
23197 PyObject * obj0 = 0 ;
23198 char * kwnames[] = {
23199 (char *) "country", NULL
23200 };
23201
23202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23203 ecode1 = SWIG_AsVal_int(obj0, &val1);
23204 if (!SWIG_IsOK(ecode1)) {
23205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23206 }
23207 arg1 = static_cast< wxDateTime::Country >(val1);
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 wxDateTime::SetCountry(arg1);
23211 wxPyEndAllowThreads(__tstate);
23212 if (PyErr_Occurred()) SWIG_fail;
23213 }
23214 resultobj = SWIG_Py_Void();
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23222 PyObject *resultobj = 0;
23223 wxDateTime::Country result;
23224
23225 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (wxDateTime::Country)wxDateTime::GetCountry();
23229 wxPyEndAllowThreads(__tstate);
23230 if (PyErr_Occurred()) SWIG_fail;
23231 }
23232 resultobj = SWIG_From_int(static_cast< int >(result));
23233 return resultobj;
23234 fail:
23235 return NULL;
23236 }
23237
23238
23239 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23240 PyObject *resultobj = 0;
23241 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23242 bool result;
23243 int val1 ;
23244 int ecode1 = 0 ;
23245 PyObject * obj0 = 0 ;
23246 char * kwnames[] = {
23247 (char *) "country", NULL
23248 };
23249
23250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23251 if (obj0) {
23252 ecode1 = SWIG_AsVal_int(obj0, &val1);
23253 if (!SWIG_IsOK(ecode1)) {
23254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23255 }
23256 arg1 = static_cast< wxDateTime::Country >(val1);
23257 }
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 {
23265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23266 }
23267 return resultobj;
23268 fail:
23269 return NULL;
23270 }
23271
23272
23273 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23274 PyObject *resultobj = 0;
23275 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23276 int result;
23277 int val1 ;
23278 int ecode1 = 0 ;
23279 PyObject * obj0 = 0 ;
23280 char * kwnames[] = {
23281 (char *) "cal", NULL
23282 };
23283
23284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23285 if (obj0) {
23286 ecode1 = SWIG_AsVal_int(obj0, &val1);
23287 if (!SWIG_IsOK(ecode1)) {
23288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23289 }
23290 arg1 = static_cast< wxDateTime::Calendar >(val1);
23291 }
23292 {
23293 PyThreadState* __tstate = wxPyBeginAllowThreads();
23294 result = (int)wxDateTime::GetCurrentYear(arg1);
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 resultobj = SWIG_From_int(static_cast< int >(result));
23299 return resultobj;
23300 fail:
23301 return NULL;
23302 }
23303
23304
23305 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23306 PyObject *resultobj = 0;
23307 int arg1 ;
23308 int result;
23309 int val1 ;
23310 int ecode1 = 0 ;
23311 PyObject * obj0 = 0 ;
23312 char * kwnames[] = {
23313 (char *) "year", NULL
23314 };
23315
23316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23317 ecode1 = SWIG_AsVal_int(obj0, &val1);
23318 if (!SWIG_IsOK(ecode1)) {
23319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23320 }
23321 arg1 = static_cast< int >(val1);
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = (int)wxDateTime::ConvertYearToBC(arg1);
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 resultobj = SWIG_From_int(static_cast< int >(result));
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj = 0;
23337 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23338 wxDateTime::Month result;
23339 int val1 ;
23340 int ecode1 = 0 ;
23341 PyObject * obj0 = 0 ;
23342 char * kwnames[] = {
23343 (char *) "cal", NULL
23344 };
23345
23346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23347 if (obj0) {
23348 ecode1 = SWIG_AsVal_int(obj0, &val1);
23349 if (!SWIG_IsOK(ecode1)) {
23350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23351 }
23352 arg1 = static_cast< wxDateTime::Calendar >(val1);
23353 }
23354 {
23355 PyThreadState* __tstate = wxPyBeginAllowThreads();
23356 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23357 wxPyEndAllowThreads(__tstate);
23358 if (PyErr_Occurred()) SWIG_fail;
23359 }
23360 resultobj = SWIG_From_int(static_cast< int >(result));
23361 return resultobj;
23362 fail:
23363 return NULL;
23364 }
23365
23366
23367 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23368 PyObject *resultobj = 0;
23369 int arg1 = (int) wxDateTime::Inv_Year ;
23370 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23371 bool result;
23372 int val1 ;
23373 int ecode1 = 0 ;
23374 int val2 ;
23375 int ecode2 = 0 ;
23376 PyObject * obj0 = 0 ;
23377 PyObject * obj1 = 0 ;
23378 char * kwnames[] = {
23379 (char *) "year",(char *) "cal", NULL
23380 };
23381
23382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23383 if (obj0) {
23384 ecode1 = SWIG_AsVal_int(obj0, &val1);
23385 if (!SWIG_IsOK(ecode1)) {
23386 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23387 }
23388 arg1 = static_cast< int >(val1);
23389 }
23390 if (obj1) {
23391 ecode2 = SWIG_AsVal_int(obj1, &val2);
23392 if (!SWIG_IsOK(ecode2)) {
23393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23394 }
23395 arg2 = static_cast< wxDateTime::Calendar >(val2);
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23400 wxPyEndAllowThreads(__tstate);
23401 if (PyErr_Occurred()) SWIG_fail;
23402 }
23403 {
23404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23405 }
23406 return resultobj;
23407 fail:
23408 return NULL;
23409 }
23410
23411
23412 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23413 PyObject *resultobj = 0;
23414 int arg1 = (int) wxDateTime::Inv_Year ;
23415 int result;
23416 int val1 ;
23417 int ecode1 = 0 ;
23418 PyObject * obj0 = 0 ;
23419 char * kwnames[] = {
23420 (char *) "year", NULL
23421 };
23422
23423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23424 if (obj0) {
23425 ecode1 = SWIG_AsVal_int(obj0, &val1);
23426 if (!SWIG_IsOK(ecode1)) {
23427 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23428 }
23429 arg1 = static_cast< int >(val1);
23430 }
23431 {
23432 PyThreadState* __tstate = wxPyBeginAllowThreads();
23433 result = (int)wxDateTime::GetCentury(arg1);
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 resultobj = SWIG_From_int(static_cast< int >(result));
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj = 0;
23446 int arg1 ;
23447 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23448 int result;
23449 int val1 ;
23450 int ecode1 = 0 ;
23451 int val2 ;
23452 int ecode2 = 0 ;
23453 PyObject * obj0 = 0 ;
23454 PyObject * obj1 = 0 ;
23455 char * kwnames[] = {
23456 (char *) "year",(char *) "cal", NULL
23457 };
23458
23459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23460 ecode1 = SWIG_AsVal_int(obj0, &val1);
23461 if (!SWIG_IsOK(ecode1)) {
23462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23463 }
23464 arg1 = static_cast< int >(val1);
23465 if (obj1) {
23466 ecode2 = SWIG_AsVal_int(obj1, &val2);
23467 if (!SWIG_IsOK(ecode2)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23469 }
23470 arg2 = static_cast< wxDateTime::Calendar >(val2);
23471 }
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23475 wxPyEndAllowThreads(__tstate);
23476 if (PyErr_Occurred()) SWIG_fail;
23477 }
23478 resultobj = SWIG_From_int(static_cast< int >(result));
23479 return resultobj;
23480 fail:
23481 return NULL;
23482 }
23483
23484
23485 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23486 PyObject *resultobj = 0;
23487 wxDateTime::Month arg1 ;
23488 int arg2 = (int) wxDateTime::Inv_Year ;
23489 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23490 int result;
23491 int val1 ;
23492 int ecode1 = 0 ;
23493 int val2 ;
23494 int ecode2 = 0 ;
23495 int val3 ;
23496 int ecode3 = 0 ;
23497 PyObject * obj0 = 0 ;
23498 PyObject * obj1 = 0 ;
23499 PyObject * obj2 = 0 ;
23500 char * kwnames[] = {
23501 (char *) "month",(char *) "year",(char *) "cal", NULL
23502 };
23503
23504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23505 ecode1 = SWIG_AsVal_int(obj0, &val1);
23506 if (!SWIG_IsOK(ecode1)) {
23507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23508 }
23509 arg1 = static_cast< wxDateTime::Month >(val1);
23510 if (obj1) {
23511 ecode2 = SWIG_AsVal_int(obj1, &val2);
23512 if (!SWIG_IsOK(ecode2)) {
23513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23514 }
23515 arg2 = static_cast< int >(val2);
23516 }
23517 if (obj2) {
23518 ecode3 = SWIG_AsVal_int(obj2, &val3);
23519 if (!SWIG_IsOK(ecode3)) {
23520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23521 }
23522 arg3 = static_cast< wxDateTime::Calendar >(val3);
23523 }
23524 {
23525 PyThreadState* __tstate = wxPyBeginAllowThreads();
23526 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23527 wxPyEndAllowThreads(__tstate);
23528 if (PyErr_Occurred()) SWIG_fail;
23529 }
23530 resultobj = SWIG_From_int(static_cast< int >(result));
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23538 PyObject *resultobj = 0;
23539 wxDateTime::Month arg1 ;
23540 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23541 wxString result;
23542 int val1 ;
23543 int ecode1 = 0 ;
23544 int val2 ;
23545 int ecode2 = 0 ;
23546 PyObject * obj0 = 0 ;
23547 PyObject * obj1 = 0 ;
23548 char * kwnames[] = {
23549 (char *) "month",(char *) "flags", NULL
23550 };
23551
23552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23553 ecode1 = SWIG_AsVal_int(obj0, &val1);
23554 if (!SWIG_IsOK(ecode1)) {
23555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23556 }
23557 arg1 = static_cast< wxDateTime::Month >(val1);
23558 if (obj1) {
23559 ecode2 = SWIG_AsVal_int(obj1, &val2);
23560 if (!SWIG_IsOK(ecode2)) {
23561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23562 }
23563 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23564 }
23565 {
23566 PyThreadState* __tstate = wxPyBeginAllowThreads();
23567 result = wxDateTime::GetMonthName(arg1,arg2);
23568 wxPyEndAllowThreads(__tstate);
23569 if (PyErr_Occurred()) SWIG_fail;
23570 }
23571 {
23572 #if wxUSE_UNICODE
23573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23574 #else
23575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23576 #endif
23577 }
23578 return resultobj;
23579 fail:
23580 return NULL;
23581 }
23582
23583
23584 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23585 PyObject *resultobj = 0;
23586 wxDateTime::WeekDay arg1 ;
23587 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23588 wxString result;
23589 int val1 ;
23590 int ecode1 = 0 ;
23591 int val2 ;
23592 int ecode2 = 0 ;
23593 PyObject * obj0 = 0 ;
23594 PyObject * obj1 = 0 ;
23595 char * kwnames[] = {
23596 (char *) "weekday",(char *) "flags", NULL
23597 };
23598
23599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23600 ecode1 = SWIG_AsVal_int(obj0, &val1);
23601 if (!SWIG_IsOK(ecode1)) {
23602 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23603 }
23604 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23605 if (obj1) {
23606 ecode2 = SWIG_AsVal_int(obj1, &val2);
23607 if (!SWIG_IsOK(ecode2)) {
23608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23609 }
23610 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23611 }
23612 {
23613 PyThreadState* __tstate = wxPyBeginAllowThreads();
23614 result = wxDateTime::GetWeekDayName(arg1,arg2);
23615 wxPyEndAllowThreads(__tstate);
23616 if (PyErr_Occurred()) SWIG_fail;
23617 }
23618 {
23619 #if wxUSE_UNICODE
23620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23621 #else
23622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23623 #endif
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23632 PyObject *resultobj = 0;
23633 PyObject *result = 0 ;
23634
23635 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23636 {
23637 PyThreadState* __tstate = wxPyBeginAllowThreads();
23638 result = (PyObject *)wxDateTime_GetAmPmStrings();
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 resultobj = result;
23643 return resultobj;
23644 fail:
23645 return NULL;
23646 }
23647
23648
23649 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj = 0;
23651 int arg1 = (int) wxDateTime::Inv_Year ;
23652 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23653 bool result;
23654 int val1 ;
23655 int ecode1 = 0 ;
23656 int val2 ;
23657 int ecode2 = 0 ;
23658 PyObject * obj0 = 0 ;
23659 PyObject * obj1 = 0 ;
23660 char * kwnames[] = {
23661 (char *) "year",(char *) "country", NULL
23662 };
23663
23664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23665 if (obj0) {
23666 ecode1 = SWIG_AsVal_int(obj0, &val1);
23667 if (!SWIG_IsOK(ecode1)) {
23668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23669 }
23670 arg1 = static_cast< int >(val1);
23671 }
23672 if (obj1) {
23673 ecode2 = SWIG_AsVal_int(obj1, &val2);
23674 if (!SWIG_IsOK(ecode2)) {
23675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23676 }
23677 arg2 = static_cast< wxDateTime::Country >(val2);
23678 }
23679 {
23680 PyThreadState* __tstate = wxPyBeginAllowThreads();
23681 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23682 wxPyEndAllowThreads(__tstate);
23683 if (PyErr_Occurred()) SWIG_fail;
23684 }
23685 {
23686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23687 }
23688 return resultobj;
23689 fail:
23690 return NULL;
23691 }
23692
23693
23694 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23695 PyObject *resultobj = 0;
23696 int arg1 = (int) wxDateTime::Inv_Year ;
23697 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23698 wxDateTime result;
23699 int val1 ;
23700 int ecode1 = 0 ;
23701 int val2 ;
23702 int ecode2 = 0 ;
23703 PyObject * obj0 = 0 ;
23704 PyObject * obj1 = 0 ;
23705 char * kwnames[] = {
23706 (char *) "year",(char *) "country", NULL
23707 };
23708
23709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23710 if (obj0) {
23711 ecode1 = SWIG_AsVal_int(obj0, &val1);
23712 if (!SWIG_IsOK(ecode1)) {
23713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23714 }
23715 arg1 = static_cast< int >(val1);
23716 }
23717 if (obj1) {
23718 ecode2 = SWIG_AsVal_int(obj1, &val2);
23719 if (!SWIG_IsOK(ecode2)) {
23720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23721 }
23722 arg2 = static_cast< wxDateTime::Country >(val2);
23723 }
23724 {
23725 PyThreadState* __tstate = wxPyBeginAllowThreads();
23726 result = wxDateTime::GetBeginDST(arg1,arg2);
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj = 0;
23739 int arg1 = (int) wxDateTime::Inv_Year ;
23740 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23741 wxDateTime result;
23742 int val1 ;
23743 int ecode1 = 0 ;
23744 int val2 ;
23745 int ecode2 = 0 ;
23746 PyObject * obj0 = 0 ;
23747 PyObject * obj1 = 0 ;
23748 char * kwnames[] = {
23749 (char *) "year",(char *) "country", NULL
23750 };
23751
23752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23753 if (obj0) {
23754 ecode1 = SWIG_AsVal_int(obj0, &val1);
23755 if (!SWIG_IsOK(ecode1)) {
23756 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23757 }
23758 arg1 = static_cast< int >(val1);
23759 }
23760 if (obj1) {
23761 ecode2 = SWIG_AsVal_int(obj1, &val2);
23762 if (!SWIG_IsOK(ecode2)) {
23763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23764 }
23765 arg2 = static_cast< wxDateTime::Country >(val2);
23766 }
23767 {
23768 PyThreadState* __tstate = wxPyBeginAllowThreads();
23769 result = wxDateTime::GetEndDST(arg1,arg2);
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23781 PyObject *resultobj = 0;
23782 wxDateTime result;
23783
23784 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23785 {
23786 PyThreadState* __tstate = wxPyBeginAllowThreads();
23787 result = wxDateTime::Now();
23788 wxPyEndAllowThreads(__tstate);
23789 if (PyErr_Occurred()) SWIG_fail;
23790 }
23791 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23792 return resultobj;
23793 fail:
23794 return NULL;
23795 }
23796
23797
23798 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23799 PyObject *resultobj = 0;
23800 wxDateTime result;
23801
23802 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23803 {
23804 PyThreadState* __tstate = wxPyBeginAllowThreads();
23805 result = wxDateTime::UNow();
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23810 return resultobj;
23811 fail:
23812 return NULL;
23813 }
23814
23815
23816 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23817 PyObject *resultobj = 0;
23818 wxDateTime result;
23819
23820 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23821 {
23822 PyThreadState* __tstate = wxPyBeginAllowThreads();
23823 result = wxDateTime::Today();
23824 wxPyEndAllowThreads(__tstate);
23825 if (PyErr_Occurred()) SWIG_fail;
23826 }
23827 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23828 return resultobj;
23829 fail:
23830 return NULL;
23831 }
23832
23833
23834 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23835 PyObject *resultobj = 0;
23836 wxDateTime *result = 0 ;
23837
23838 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (wxDateTime *)new wxDateTime();
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23853 PyObject *resultobj = 0;
23854 time_t arg1 ;
23855 wxDateTime *result = 0 ;
23856 unsigned int val1 ;
23857 int ecode1 = 0 ;
23858 PyObject * obj0 = 0 ;
23859 char * kwnames[] = {
23860 (char *) "timet", NULL
23861 };
23862
23863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23864 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23865 if (!SWIG_IsOK(ecode1)) {
23866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23867 }
23868 arg1 = static_cast< time_t >(val1);
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = (wxDateTime *)new wxDateTime(arg1);
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23883 PyObject *resultobj = 0;
23884 double arg1 ;
23885 wxDateTime *result = 0 ;
23886 double val1 ;
23887 int ecode1 = 0 ;
23888 PyObject * obj0 = 0 ;
23889 char * kwnames[] = {
23890 (char *) "jdn", NULL
23891 };
23892
23893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23894 ecode1 = SWIG_AsVal_double(obj0, &val1);
23895 if (!SWIG_IsOK(ecode1)) {
23896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23897 }
23898 arg1 = static_cast< double >(val1);
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 result = (wxDateTime *)new wxDateTime(arg1);
23902 wxPyEndAllowThreads(__tstate);
23903 if (PyErr_Occurred()) SWIG_fail;
23904 }
23905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23913 PyObject *resultobj = 0;
23914 int arg1 ;
23915 int arg2 = (int) 0 ;
23916 int arg3 = (int) 0 ;
23917 int arg4 = (int) 0 ;
23918 wxDateTime *result = 0 ;
23919 int val1 ;
23920 int ecode1 = 0 ;
23921 int val2 ;
23922 int ecode2 = 0 ;
23923 int val3 ;
23924 int ecode3 = 0 ;
23925 int val4 ;
23926 int ecode4 = 0 ;
23927 PyObject * obj0 = 0 ;
23928 PyObject * obj1 = 0 ;
23929 PyObject * obj2 = 0 ;
23930 PyObject * obj3 = 0 ;
23931 char * kwnames[] = {
23932 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23933 };
23934
23935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23936 ecode1 = SWIG_AsVal_int(obj0, &val1);
23937 if (!SWIG_IsOK(ecode1)) {
23938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23939 }
23940 arg1 = static_cast< int >(val1);
23941 if (obj1) {
23942 ecode2 = SWIG_AsVal_int(obj1, &val2);
23943 if (!SWIG_IsOK(ecode2)) {
23944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23945 }
23946 arg2 = static_cast< int >(val2);
23947 }
23948 if (obj2) {
23949 ecode3 = SWIG_AsVal_int(obj2, &val3);
23950 if (!SWIG_IsOK(ecode3)) {
23951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23952 }
23953 arg3 = static_cast< int >(val3);
23954 }
23955 if (obj3) {
23956 ecode4 = SWIG_AsVal_int(obj3, &val4);
23957 if (!SWIG_IsOK(ecode4)) {
23958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23959 }
23960 arg4 = static_cast< int >(val4);
23961 }
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23976 PyObject *resultobj = 0;
23977 int arg1 ;
23978 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23979 int arg3 = (int) wxDateTime::Inv_Year ;
23980 int arg4 = (int) 0 ;
23981 int arg5 = (int) 0 ;
23982 int arg6 = (int) 0 ;
23983 int arg7 = (int) 0 ;
23984 wxDateTime *result = 0 ;
23985 int val1 ;
23986 int ecode1 = 0 ;
23987 int val2 ;
23988 int ecode2 = 0 ;
23989 int val3 ;
23990 int ecode3 = 0 ;
23991 int val4 ;
23992 int ecode4 = 0 ;
23993 int val5 ;
23994 int ecode5 = 0 ;
23995 int val6 ;
23996 int ecode6 = 0 ;
23997 int val7 ;
23998 int ecode7 = 0 ;
23999 PyObject * obj0 = 0 ;
24000 PyObject * obj1 = 0 ;
24001 PyObject * obj2 = 0 ;
24002 PyObject * obj3 = 0 ;
24003 PyObject * obj4 = 0 ;
24004 PyObject * obj5 = 0 ;
24005 PyObject * obj6 = 0 ;
24006 char * kwnames[] = {
24007 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24008 };
24009
24010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
24011 ecode1 = SWIG_AsVal_int(obj0, &val1);
24012 if (!SWIG_IsOK(ecode1)) {
24013 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
24014 }
24015 arg1 = static_cast< int >(val1);
24016 if (obj1) {
24017 ecode2 = SWIG_AsVal_int(obj1, &val2);
24018 if (!SWIG_IsOK(ecode2)) {
24019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24020 }
24021 arg2 = static_cast< wxDateTime::Month >(val2);
24022 }
24023 if (obj2) {
24024 ecode3 = SWIG_AsVal_int(obj2, &val3);
24025 if (!SWIG_IsOK(ecode3)) {
24026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24027 }
24028 arg3 = static_cast< int >(val3);
24029 }
24030 if (obj3) {
24031 ecode4 = SWIG_AsVal_int(obj3, &val4);
24032 if (!SWIG_IsOK(ecode4)) {
24033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24034 }
24035 arg4 = static_cast< int >(val4);
24036 }
24037 if (obj4) {
24038 ecode5 = SWIG_AsVal_int(obj4, &val5);
24039 if (!SWIG_IsOK(ecode5)) {
24040 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24041 }
24042 arg5 = static_cast< int >(val5);
24043 }
24044 if (obj5) {
24045 ecode6 = SWIG_AsVal_int(obj5, &val6);
24046 if (!SWIG_IsOK(ecode6)) {
24047 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24048 }
24049 arg6 = static_cast< int >(val6);
24050 }
24051 if (obj6) {
24052 ecode7 = SWIG_AsVal_int(obj6, &val7);
24053 if (!SWIG_IsOK(ecode7)) {
24054 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24055 }
24056 arg7 = static_cast< int >(val7);
24057 }
24058 {
24059 PyThreadState* __tstate = wxPyBeginAllowThreads();
24060 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24061 wxPyEndAllowThreads(__tstate);
24062 if (PyErr_Occurred()) SWIG_fail;
24063 }
24064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj = 0;
24073 wxDateTime *arg1 = 0 ;
24074 wxDateTime *result = 0 ;
24075 void *argp1 = 0 ;
24076 int res1 = 0 ;
24077 PyObject * obj0 = 0 ;
24078 char * kwnames[] = {
24079 (char *) "date", NULL
24080 };
24081
24082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24083 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24084 if (!SWIG_IsOK(res1)) {
24085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24086 }
24087 if (!argp1) {
24088 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24089 }
24090 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24091 {
24092 PyThreadState* __tstate = wxPyBeginAllowThreads();
24093 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24094 wxPyEndAllowThreads(__tstate);
24095 if (PyErr_Occurred()) SWIG_fail;
24096 }
24097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24105 PyObject *resultobj = 0;
24106 wxDateTime *arg1 = (wxDateTime *) 0 ;
24107 void *argp1 = 0 ;
24108 int res1 = 0 ;
24109 PyObject *swig_obj[1] ;
24110
24111 if (!args) SWIG_fail;
24112 swig_obj[0] = args;
24113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24114 if (!SWIG_IsOK(res1)) {
24115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24116 }
24117 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24118 {
24119 PyThreadState* __tstate = wxPyBeginAllowThreads();
24120 delete arg1;
24121
24122 wxPyEndAllowThreads(__tstate);
24123 if (PyErr_Occurred()) SWIG_fail;
24124 }
24125 resultobj = SWIG_Py_Void();
24126 return resultobj;
24127 fail:
24128 return NULL;
24129 }
24130
24131
24132 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24133 PyObject *resultobj = 0;
24134 wxDateTime *arg1 = (wxDateTime *) 0 ;
24135 wxDateTime *result = 0 ;
24136 void *argp1 = 0 ;
24137 int res1 = 0 ;
24138 PyObject *swig_obj[1] ;
24139
24140 if (!args) SWIG_fail;
24141 swig_obj[0] = args;
24142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24143 if (!SWIG_IsOK(res1)) {
24144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24145 }
24146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24147 {
24148 PyThreadState* __tstate = wxPyBeginAllowThreads();
24149 {
24150 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24151 result = (wxDateTime *) &_result_ref;
24152 }
24153 wxPyEndAllowThreads(__tstate);
24154 if (PyErr_Occurred()) SWIG_fail;
24155 }
24156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24157 return resultobj;
24158 fail:
24159 return NULL;
24160 }
24161
24162
24163 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24164 PyObject *resultobj = 0;
24165 wxDateTime *arg1 = (wxDateTime *) 0 ;
24166 time_t arg2 ;
24167 wxDateTime *result = 0 ;
24168 void *argp1 = 0 ;
24169 int res1 = 0 ;
24170 unsigned int val2 ;
24171 int ecode2 = 0 ;
24172 PyObject * obj0 = 0 ;
24173 PyObject * obj1 = 0 ;
24174 char * kwnames[] = {
24175 (char *) "self",(char *) "timet", NULL
24176 };
24177
24178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24180 if (!SWIG_IsOK(res1)) {
24181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24182 }
24183 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24184 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24185 if (!SWIG_IsOK(ecode2)) {
24186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24187 }
24188 arg2 = static_cast< time_t >(val2);
24189 {
24190 PyThreadState* __tstate = wxPyBeginAllowThreads();
24191 {
24192 wxDateTime &_result_ref = (arg1)->Set(arg2);
24193 result = (wxDateTime *) &_result_ref;
24194 }
24195 wxPyEndAllowThreads(__tstate);
24196 if (PyErr_Occurred()) SWIG_fail;
24197 }
24198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24199 return resultobj;
24200 fail:
24201 return NULL;
24202 }
24203
24204
24205 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24206 PyObject *resultobj = 0;
24207 wxDateTime *arg1 = (wxDateTime *) 0 ;
24208 double arg2 ;
24209 wxDateTime *result = 0 ;
24210 void *argp1 = 0 ;
24211 int res1 = 0 ;
24212 double val2 ;
24213 int ecode2 = 0 ;
24214 PyObject * obj0 = 0 ;
24215 PyObject * obj1 = 0 ;
24216 char * kwnames[] = {
24217 (char *) "self",(char *) "jdn", NULL
24218 };
24219
24220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24222 if (!SWIG_IsOK(res1)) {
24223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24224 }
24225 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24226 ecode2 = SWIG_AsVal_double(obj1, &val2);
24227 if (!SWIG_IsOK(ecode2)) {
24228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24229 }
24230 arg2 = static_cast< double >(val2);
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 {
24234 wxDateTime &_result_ref = (arg1)->Set(arg2);
24235 result = (wxDateTime *) &_result_ref;
24236 }
24237 wxPyEndAllowThreads(__tstate);
24238 if (PyErr_Occurred()) SWIG_fail;
24239 }
24240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24241 return resultobj;
24242 fail:
24243 return NULL;
24244 }
24245
24246
24247 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24248 PyObject *resultobj = 0;
24249 wxDateTime *arg1 = (wxDateTime *) 0 ;
24250 int arg2 ;
24251 int arg3 = (int) 0 ;
24252 int arg4 = (int) 0 ;
24253 int arg5 = (int) 0 ;
24254 wxDateTime *result = 0 ;
24255 void *argp1 = 0 ;
24256 int res1 = 0 ;
24257 int val2 ;
24258 int ecode2 = 0 ;
24259 int val3 ;
24260 int ecode3 = 0 ;
24261 int val4 ;
24262 int ecode4 = 0 ;
24263 int val5 ;
24264 int ecode5 = 0 ;
24265 PyObject * obj0 = 0 ;
24266 PyObject * obj1 = 0 ;
24267 PyObject * obj2 = 0 ;
24268 PyObject * obj3 = 0 ;
24269 PyObject * obj4 = 0 ;
24270 char * kwnames[] = {
24271 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24272 };
24273
24274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24278 }
24279 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24280 ecode2 = SWIG_AsVal_int(obj1, &val2);
24281 if (!SWIG_IsOK(ecode2)) {
24282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24283 }
24284 arg2 = static_cast< int >(val2);
24285 if (obj2) {
24286 ecode3 = SWIG_AsVal_int(obj2, &val3);
24287 if (!SWIG_IsOK(ecode3)) {
24288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24289 }
24290 arg3 = static_cast< int >(val3);
24291 }
24292 if (obj3) {
24293 ecode4 = SWIG_AsVal_int(obj3, &val4);
24294 if (!SWIG_IsOK(ecode4)) {
24295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24296 }
24297 arg4 = static_cast< int >(val4);
24298 }
24299 if (obj4) {
24300 ecode5 = SWIG_AsVal_int(obj4, &val5);
24301 if (!SWIG_IsOK(ecode5)) {
24302 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24303 }
24304 arg5 = static_cast< int >(val5);
24305 }
24306 {
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 {
24309 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24310 result = (wxDateTime *) &_result_ref;
24311 }
24312 wxPyEndAllowThreads(__tstate);
24313 if (PyErr_Occurred()) SWIG_fail;
24314 }
24315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24316 return resultobj;
24317 fail:
24318 return NULL;
24319 }
24320
24321
24322 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24323 PyObject *resultobj = 0;
24324 wxDateTime *arg1 = (wxDateTime *) 0 ;
24325 int arg2 ;
24326 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24327 int arg4 = (int) wxDateTime::Inv_Year ;
24328 int arg5 = (int) 0 ;
24329 int arg6 = (int) 0 ;
24330 int arg7 = (int) 0 ;
24331 int arg8 = (int) 0 ;
24332 wxDateTime *result = 0 ;
24333 void *argp1 = 0 ;
24334 int res1 = 0 ;
24335 int val2 ;
24336 int ecode2 = 0 ;
24337 int val3 ;
24338 int ecode3 = 0 ;
24339 int val4 ;
24340 int ecode4 = 0 ;
24341 int val5 ;
24342 int ecode5 = 0 ;
24343 int val6 ;
24344 int ecode6 = 0 ;
24345 int val7 ;
24346 int ecode7 = 0 ;
24347 int val8 ;
24348 int ecode8 = 0 ;
24349 PyObject * obj0 = 0 ;
24350 PyObject * obj1 = 0 ;
24351 PyObject * obj2 = 0 ;
24352 PyObject * obj3 = 0 ;
24353 PyObject * obj4 = 0 ;
24354 PyObject * obj5 = 0 ;
24355 PyObject * obj6 = 0 ;
24356 PyObject * obj7 = 0 ;
24357 char * kwnames[] = {
24358 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24359 };
24360
24361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24363 if (!SWIG_IsOK(res1)) {
24364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24365 }
24366 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24367 ecode2 = SWIG_AsVal_int(obj1, &val2);
24368 if (!SWIG_IsOK(ecode2)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24370 }
24371 arg2 = static_cast< int >(val2);
24372 if (obj2) {
24373 ecode3 = SWIG_AsVal_int(obj2, &val3);
24374 if (!SWIG_IsOK(ecode3)) {
24375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24376 }
24377 arg3 = static_cast< wxDateTime::Month >(val3);
24378 }
24379 if (obj3) {
24380 ecode4 = SWIG_AsVal_int(obj3, &val4);
24381 if (!SWIG_IsOK(ecode4)) {
24382 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24383 }
24384 arg4 = static_cast< int >(val4);
24385 }
24386 if (obj4) {
24387 ecode5 = SWIG_AsVal_int(obj4, &val5);
24388 if (!SWIG_IsOK(ecode5)) {
24389 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24390 }
24391 arg5 = static_cast< int >(val5);
24392 }
24393 if (obj5) {
24394 ecode6 = SWIG_AsVal_int(obj5, &val6);
24395 if (!SWIG_IsOK(ecode6)) {
24396 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24397 }
24398 arg6 = static_cast< int >(val6);
24399 }
24400 if (obj6) {
24401 ecode7 = SWIG_AsVal_int(obj6, &val7);
24402 if (!SWIG_IsOK(ecode7)) {
24403 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24404 }
24405 arg7 = static_cast< int >(val7);
24406 }
24407 if (obj7) {
24408 ecode8 = SWIG_AsVal_int(obj7, &val8);
24409 if (!SWIG_IsOK(ecode8)) {
24410 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24411 }
24412 arg8 = static_cast< int >(val8);
24413 }
24414 {
24415 PyThreadState* __tstate = wxPyBeginAllowThreads();
24416 {
24417 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24418 result = (wxDateTime *) &_result_ref;
24419 }
24420 wxPyEndAllowThreads(__tstate);
24421 if (PyErr_Occurred()) SWIG_fail;
24422 }
24423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24431 PyObject *resultobj = 0;
24432 wxDateTime *arg1 = (wxDateTime *) 0 ;
24433 wxDateTime *result = 0 ;
24434 void *argp1 = 0 ;
24435 int res1 = 0 ;
24436 PyObject *swig_obj[1] ;
24437
24438 if (!args) SWIG_fail;
24439 swig_obj[0] = args;
24440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24441 if (!SWIG_IsOK(res1)) {
24442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24443 }
24444 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24445 {
24446 PyThreadState* __tstate = wxPyBeginAllowThreads();
24447 {
24448 wxDateTime &_result_ref = (arg1)->ResetTime();
24449 result = (wxDateTime *) &_result_ref;
24450 }
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24462 PyObject *resultobj = 0;
24463 wxDateTime *arg1 = (wxDateTime *) 0 ;
24464 int arg2 ;
24465 wxDateTime *result = 0 ;
24466 void *argp1 = 0 ;
24467 int res1 = 0 ;
24468 int val2 ;
24469 int ecode2 = 0 ;
24470 PyObject * obj0 = 0 ;
24471 PyObject * obj1 = 0 ;
24472 char * kwnames[] = {
24473 (char *) "self",(char *) "year", NULL
24474 };
24475
24476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24478 if (!SWIG_IsOK(res1)) {
24479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24480 }
24481 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24482 ecode2 = SWIG_AsVal_int(obj1, &val2);
24483 if (!SWIG_IsOK(ecode2)) {
24484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24485 }
24486 arg2 = static_cast< int >(val2);
24487 {
24488 PyThreadState* __tstate = wxPyBeginAllowThreads();
24489 {
24490 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24491 result = (wxDateTime *) &_result_ref;
24492 }
24493 wxPyEndAllowThreads(__tstate);
24494 if (PyErr_Occurred()) SWIG_fail;
24495 }
24496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24504 PyObject *resultobj = 0;
24505 wxDateTime *arg1 = (wxDateTime *) 0 ;
24506 wxDateTime::Month arg2 ;
24507 wxDateTime *result = 0 ;
24508 void *argp1 = 0 ;
24509 int res1 = 0 ;
24510 int val2 ;
24511 int ecode2 = 0 ;
24512 PyObject * obj0 = 0 ;
24513 PyObject * obj1 = 0 ;
24514 char * kwnames[] = {
24515 (char *) "self",(char *) "month", NULL
24516 };
24517
24518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24520 if (!SWIG_IsOK(res1)) {
24521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24522 }
24523 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24524 ecode2 = SWIG_AsVal_int(obj1, &val2);
24525 if (!SWIG_IsOK(ecode2)) {
24526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24527 }
24528 arg2 = static_cast< wxDateTime::Month >(val2);
24529 {
24530 PyThreadState* __tstate = wxPyBeginAllowThreads();
24531 {
24532 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24533 result = (wxDateTime *) &_result_ref;
24534 }
24535 wxPyEndAllowThreads(__tstate);
24536 if (PyErr_Occurred()) SWIG_fail;
24537 }
24538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24539 return resultobj;
24540 fail:
24541 return NULL;
24542 }
24543
24544
24545 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24546 PyObject *resultobj = 0;
24547 wxDateTime *arg1 = (wxDateTime *) 0 ;
24548 int arg2 ;
24549 wxDateTime *result = 0 ;
24550 void *argp1 = 0 ;
24551 int res1 = 0 ;
24552 int val2 ;
24553 int ecode2 = 0 ;
24554 PyObject * obj0 = 0 ;
24555 PyObject * obj1 = 0 ;
24556 char * kwnames[] = {
24557 (char *) "self",(char *) "day", NULL
24558 };
24559
24560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24562 if (!SWIG_IsOK(res1)) {
24563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24564 }
24565 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24566 ecode2 = SWIG_AsVal_int(obj1, &val2);
24567 if (!SWIG_IsOK(ecode2)) {
24568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24569 }
24570 arg2 = static_cast< int >(val2);
24571 {
24572 PyThreadState* __tstate = wxPyBeginAllowThreads();
24573 {
24574 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24575 result = (wxDateTime *) &_result_ref;
24576 }
24577 wxPyEndAllowThreads(__tstate);
24578 if (PyErr_Occurred()) SWIG_fail;
24579 }
24580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj = 0;
24589 wxDateTime *arg1 = (wxDateTime *) 0 ;
24590 int arg2 ;
24591 wxDateTime *result = 0 ;
24592 void *argp1 = 0 ;
24593 int res1 = 0 ;
24594 int val2 ;
24595 int ecode2 = 0 ;
24596 PyObject * obj0 = 0 ;
24597 PyObject * obj1 = 0 ;
24598 char * kwnames[] = {
24599 (char *) "self",(char *) "hour", NULL
24600 };
24601
24602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24604 if (!SWIG_IsOK(res1)) {
24605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24606 }
24607 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24608 ecode2 = SWIG_AsVal_int(obj1, &val2);
24609 if (!SWIG_IsOK(ecode2)) {
24610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24611 }
24612 arg2 = static_cast< int >(val2);
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 {
24616 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24617 result = (wxDateTime *) &_result_ref;
24618 }
24619 wxPyEndAllowThreads(__tstate);
24620 if (PyErr_Occurred()) SWIG_fail;
24621 }
24622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24630 PyObject *resultobj = 0;
24631 wxDateTime *arg1 = (wxDateTime *) 0 ;
24632 int arg2 ;
24633 wxDateTime *result = 0 ;
24634 void *argp1 = 0 ;
24635 int res1 = 0 ;
24636 int val2 ;
24637 int ecode2 = 0 ;
24638 PyObject * obj0 = 0 ;
24639 PyObject * obj1 = 0 ;
24640 char * kwnames[] = {
24641 (char *) "self",(char *) "minute", NULL
24642 };
24643
24644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24646 if (!SWIG_IsOK(res1)) {
24647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24648 }
24649 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24650 ecode2 = SWIG_AsVal_int(obj1, &val2);
24651 if (!SWIG_IsOK(ecode2)) {
24652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24653 }
24654 arg2 = static_cast< int >(val2);
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 {
24658 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24659 result = (wxDateTime *) &_result_ref;
24660 }
24661 wxPyEndAllowThreads(__tstate);
24662 if (PyErr_Occurred()) SWIG_fail;
24663 }
24664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24665 return resultobj;
24666 fail:
24667 return NULL;
24668 }
24669
24670
24671 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj = 0;
24673 wxDateTime *arg1 = (wxDateTime *) 0 ;
24674 int arg2 ;
24675 wxDateTime *result = 0 ;
24676 void *argp1 = 0 ;
24677 int res1 = 0 ;
24678 int val2 ;
24679 int ecode2 = 0 ;
24680 PyObject * obj0 = 0 ;
24681 PyObject * obj1 = 0 ;
24682 char * kwnames[] = {
24683 (char *) "self",(char *) "second", NULL
24684 };
24685
24686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24688 if (!SWIG_IsOK(res1)) {
24689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24690 }
24691 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24692 ecode2 = SWIG_AsVal_int(obj1, &val2);
24693 if (!SWIG_IsOK(ecode2)) {
24694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24695 }
24696 arg2 = static_cast< int >(val2);
24697 {
24698 PyThreadState* __tstate = wxPyBeginAllowThreads();
24699 {
24700 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24701 result = (wxDateTime *) &_result_ref;
24702 }
24703 wxPyEndAllowThreads(__tstate);
24704 if (PyErr_Occurred()) SWIG_fail;
24705 }
24706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24707 return resultobj;
24708 fail:
24709 return NULL;
24710 }
24711
24712
24713 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24714 PyObject *resultobj = 0;
24715 wxDateTime *arg1 = (wxDateTime *) 0 ;
24716 int arg2 ;
24717 wxDateTime *result = 0 ;
24718 void *argp1 = 0 ;
24719 int res1 = 0 ;
24720 int val2 ;
24721 int ecode2 = 0 ;
24722 PyObject * obj0 = 0 ;
24723 PyObject * obj1 = 0 ;
24724 char * kwnames[] = {
24725 (char *) "self",(char *) "millisecond", NULL
24726 };
24727
24728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24730 if (!SWIG_IsOK(res1)) {
24731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24732 }
24733 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24734 ecode2 = SWIG_AsVal_int(obj1, &val2);
24735 if (!SWIG_IsOK(ecode2)) {
24736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24737 }
24738 arg2 = static_cast< int >(val2);
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 {
24742 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24743 result = (wxDateTime *) &_result_ref;
24744 }
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj = 0;
24757 wxDateTime *arg1 = (wxDateTime *) 0 ;
24758 wxDateTime::WeekDay arg2 ;
24759 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24760 wxDateTime *result = 0 ;
24761 void *argp1 = 0 ;
24762 int res1 = 0 ;
24763 int val2 ;
24764 int ecode2 = 0 ;
24765 int val3 ;
24766 int ecode3 = 0 ;
24767 PyObject * obj0 = 0 ;
24768 PyObject * obj1 = 0 ;
24769 PyObject * obj2 = 0 ;
24770 char * kwnames[] = {
24771 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24772 };
24773
24774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24776 if (!SWIG_IsOK(res1)) {
24777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24778 }
24779 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24780 ecode2 = SWIG_AsVal_int(obj1, &val2);
24781 if (!SWIG_IsOK(ecode2)) {
24782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24783 }
24784 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24785 if (obj2) {
24786 ecode3 = SWIG_AsVal_int(obj2, &val3);
24787 if (!SWIG_IsOK(ecode3)) {
24788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24789 }
24790 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24791 }
24792 {
24793 PyThreadState* __tstate = wxPyBeginAllowThreads();
24794 {
24795 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24796 result = (wxDateTime *) &_result_ref;
24797 }
24798 wxPyEndAllowThreads(__tstate);
24799 if (PyErr_Occurred()) SWIG_fail;
24800 }
24801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24802 return resultobj;
24803 fail:
24804 return NULL;
24805 }
24806
24807
24808 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24809 PyObject *resultobj = 0;
24810 wxDateTime *arg1 = (wxDateTime *) 0 ;
24811 wxDateTime::WeekDay arg2 ;
24812 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24813 wxDateTime result;
24814 void *argp1 = 0 ;
24815 int res1 = 0 ;
24816 int val2 ;
24817 int ecode2 = 0 ;
24818 int val3 ;
24819 int ecode3 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 PyObject * obj1 = 0 ;
24822 PyObject * obj2 = 0 ;
24823 char * kwnames[] = {
24824 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24825 };
24826
24827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24829 if (!SWIG_IsOK(res1)) {
24830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24831 }
24832 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24833 ecode2 = SWIG_AsVal_int(obj1, &val2);
24834 if (!SWIG_IsOK(ecode2)) {
24835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24836 }
24837 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24838 if (obj2) {
24839 ecode3 = SWIG_AsVal_int(obj2, &val3);
24840 if (!SWIG_IsOK(ecode3)) {
24841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24842 }
24843 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24844 }
24845 {
24846 PyThreadState* __tstate = wxPyBeginAllowThreads();
24847 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24848 wxPyEndAllowThreads(__tstate);
24849 if (PyErr_Occurred()) SWIG_fail;
24850 }
24851 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24852 return resultobj;
24853 fail:
24854 return NULL;
24855 }
24856
24857
24858 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24859 PyObject *resultobj = 0;
24860 wxDateTime *arg1 = (wxDateTime *) 0 ;
24861 wxDateTime::WeekDay arg2 ;
24862 wxDateTime *result = 0 ;
24863 void *argp1 = 0 ;
24864 int res1 = 0 ;
24865 int val2 ;
24866 int ecode2 = 0 ;
24867 PyObject * obj0 = 0 ;
24868 PyObject * obj1 = 0 ;
24869 char * kwnames[] = {
24870 (char *) "self",(char *) "weekday", NULL
24871 };
24872
24873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24875 if (!SWIG_IsOK(res1)) {
24876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24877 }
24878 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24879 ecode2 = SWIG_AsVal_int(obj1, &val2);
24880 if (!SWIG_IsOK(ecode2)) {
24881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24882 }
24883 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24884 {
24885 PyThreadState* __tstate = wxPyBeginAllowThreads();
24886 {
24887 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24888 result = (wxDateTime *) &_result_ref;
24889 }
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24901 PyObject *resultobj = 0;
24902 wxDateTime *arg1 = (wxDateTime *) 0 ;
24903 wxDateTime::WeekDay arg2 ;
24904 wxDateTime result;
24905 void *argp1 = 0 ;
24906 int res1 = 0 ;
24907 int val2 ;
24908 int ecode2 = 0 ;
24909 PyObject * obj0 = 0 ;
24910 PyObject * obj1 = 0 ;
24911 char * kwnames[] = {
24912 (char *) "self",(char *) "weekday", NULL
24913 };
24914
24915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24917 if (!SWIG_IsOK(res1)) {
24918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24919 }
24920 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24921 ecode2 = SWIG_AsVal_int(obj1, &val2);
24922 if (!SWIG_IsOK(ecode2)) {
24923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24924 }
24925 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24926 {
24927 PyThreadState* __tstate = wxPyBeginAllowThreads();
24928 result = (arg1)->GetNextWeekDay(arg2);
24929 wxPyEndAllowThreads(__tstate);
24930 if (PyErr_Occurred()) SWIG_fail;
24931 }
24932 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24940 PyObject *resultobj = 0;
24941 wxDateTime *arg1 = (wxDateTime *) 0 ;
24942 wxDateTime::WeekDay arg2 ;
24943 wxDateTime *result = 0 ;
24944 void *argp1 = 0 ;
24945 int res1 = 0 ;
24946 int val2 ;
24947 int ecode2 = 0 ;
24948 PyObject * obj0 = 0 ;
24949 PyObject * obj1 = 0 ;
24950 char * kwnames[] = {
24951 (char *) "self",(char *) "weekday", NULL
24952 };
24953
24954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24958 }
24959 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24960 ecode2 = SWIG_AsVal_int(obj1, &val2);
24961 if (!SWIG_IsOK(ecode2)) {
24962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24963 }
24964 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24965 {
24966 PyThreadState* __tstate = wxPyBeginAllowThreads();
24967 {
24968 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24969 result = (wxDateTime *) &_result_ref;
24970 }
24971 wxPyEndAllowThreads(__tstate);
24972 if (PyErr_Occurred()) SWIG_fail;
24973 }
24974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24982 PyObject *resultobj = 0;
24983 wxDateTime *arg1 = (wxDateTime *) 0 ;
24984 wxDateTime::WeekDay arg2 ;
24985 wxDateTime result;
24986 void *argp1 = 0 ;
24987 int res1 = 0 ;
24988 int val2 ;
24989 int ecode2 = 0 ;
24990 PyObject * obj0 = 0 ;
24991 PyObject * obj1 = 0 ;
24992 char * kwnames[] = {
24993 (char *) "self",(char *) "weekday", NULL
24994 };
24995
24996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24998 if (!SWIG_IsOK(res1)) {
24999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25000 }
25001 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25002 ecode2 = SWIG_AsVal_int(obj1, &val2);
25003 if (!SWIG_IsOK(ecode2)) {
25004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25005 }
25006 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25007 {
25008 PyThreadState* __tstate = wxPyBeginAllowThreads();
25009 result = (arg1)->GetPrevWeekDay(arg2);
25010 wxPyEndAllowThreads(__tstate);
25011 if (PyErr_Occurred()) SWIG_fail;
25012 }
25013 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25021 PyObject *resultobj = 0;
25022 wxDateTime *arg1 = (wxDateTime *) 0 ;
25023 wxDateTime::WeekDay arg2 ;
25024 int arg3 = (int) 1 ;
25025 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25026 int arg5 = (int) wxDateTime::Inv_Year ;
25027 bool result;
25028 void *argp1 = 0 ;
25029 int res1 = 0 ;
25030 int val2 ;
25031 int ecode2 = 0 ;
25032 int val3 ;
25033 int ecode3 = 0 ;
25034 int val4 ;
25035 int ecode4 = 0 ;
25036 int val5 ;
25037 int ecode5 = 0 ;
25038 PyObject * obj0 = 0 ;
25039 PyObject * obj1 = 0 ;
25040 PyObject * obj2 = 0 ;
25041 PyObject * obj3 = 0 ;
25042 PyObject * obj4 = 0 ;
25043 char * kwnames[] = {
25044 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25045 };
25046
25047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25049 if (!SWIG_IsOK(res1)) {
25050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25051 }
25052 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25053 ecode2 = SWIG_AsVal_int(obj1, &val2);
25054 if (!SWIG_IsOK(ecode2)) {
25055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25056 }
25057 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25058 if (obj2) {
25059 ecode3 = SWIG_AsVal_int(obj2, &val3);
25060 if (!SWIG_IsOK(ecode3)) {
25061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25062 }
25063 arg3 = static_cast< int >(val3);
25064 }
25065 if (obj3) {
25066 ecode4 = SWIG_AsVal_int(obj3, &val4);
25067 if (!SWIG_IsOK(ecode4)) {
25068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25069 }
25070 arg4 = static_cast< wxDateTime::Month >(val4);
25071 }
25072 if (obj4) {
25073 ecode5 = SWIG_AsVal_int(obj4, &val5);
25074 if (!SWIG_IsOK(ecode5)) {
25075 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25076 }
25077 arg5 = static_cast< int >(val5);
25078 }
25079 {
25080 PyThreadState* __tstate = wxPyBeginAllowThreads();
25081 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25082 wxPyEndAllowThreads(__tstate);
25083 if (PyErr_Occurred()) SWIG_fail;
25084 }
25085 {
25086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25087 }
25088 return resultobj;
25089 fail:
25090 return NULL;
25091 }
25092
25093
25094 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25095 PyObject *resultobj = 0;
25096 wxDateTime *arg1 = (wxDateTime *) 0 ;
25097 wxDateTime::WeekDay arg2 ;
25098 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25099 int arg4 = (int) wxDateTime::Inv_Year ;
25100 bool result;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 int val2 ;
25104 int ecode2 = 0 ;
25105 int val3 ;
25106 int ecode3 = 0 ;
25107 int val4 ;
25108 int ecode4 = 0 ;
25109 PyObject * obj0 = 0 ;
25110 PyObject * obj1 = 0 ;
25111 PyObject * obj2 = 0 ;
25112 PyObject * obj3 = 0 ;
25113 char * kwnames[] = {
25114 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25115 };
25116
25117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25119 if (!SWIG_IsOK(res1)) {
25120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25121 }
25122 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25123 ecode2 = SWIG_AsVal_int(obj1, &val2);
25124 if (!SWIG_IsOK(ecode2)) {
25125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25126 }
25127 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25128 if (obj2) {
25129 ecode3 = SWIG_AsVal_int(obj2, &val3);
25130 if (!SWIG_IsOK(ecode3)) {
25131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25132 }
25133 arg3 = static_cast< wxDateTime::Month >(val3);
25134 }
25135 if (obj3) {
25136 ecode4 = SWIG_AsVal_int(obj3, &val4);
25137 if (!SWIG_IsOK(ecode4)) {
25138 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25139 }
25140 arg4 = static_cast< int >(val4);
25141 }
25142 {
25143 PyThreadState* __tstate = wxPyBeginAllowThreads();
25144 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25145 wxPyEndAllowThreads(__tstate);
25146 if (PyErr_Occurred()) SWIG_fail;
25147 }
25148 {
25149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25150 }
25151 return resultobj;
25152 fail:
25153 return NULL;
25154 }
25155
25156
25157 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25158 PyObject *resultobj = 0;
25159 wxDateTime *arg1 = (wxDateTime *) 0 ;
25160 wxDateTime::WeekDay arg2 ;
25161 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25162 int arg4 = (int) wxDateTime::Inv_Year ;
25163 wxDateTime result;
25164 void *argp1 = 0 ;
25165 int res1 = 0 ;
25166 int val2 ;
25167 int ecode2 = 0 ;
25168 int val3 ;
25169 int ecode3 = 0 ;
25170 int val4 ;
25171 int ecode4 = 0 ;
25172 PyObject * obj0 = 0 ;
25173 PyObject * obj1 = 0 ;
25174 PyObject * obj2 = 0 ;
25175 PyObject * obj3 = 0 ;
25176 char * kwnames[] = {
25177 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25178 };
25179
25180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25182 if (!SWIG_IsOK(res1)) {
25183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25184 }
25185 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25186 ecode2 = SWIG_AsVal_int(obj1, &val2);
25187 if (!SWIG_IsOK(ecode2)) {
25188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25189 }
25190 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25191 if (obj2) {
25192 ecode3 = SWIG_AsVal_int(obj2, &val3);
25193 if (!SWIG_IsOK(ecode3)) {
25194 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25195 }
25196 arg3 = static_cast< wxDateTime::Month >(val3);
25197 }
25198 if (obj3) {
25199 ecode4 = SWIG_AsVal_int(obj3, &val4);
25200 if (!SWIG_IsOK(ecode4)) {
25201 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25202 }
25203 arg4 = static_cast< int >(val4);
25204 }
25205 {
25206 PyThreadState* __tstate = wxPyBeginAllowThreads();
25207 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25208 wxPyEndAllowThreads(__tstate);
25209 if (PyErr_Occurred()) SWIG_fail;
25210 }
25211 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25212 return resultobj;
25213 fail:
25214 return NULL;
25215 }
25216
25217
25218 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj = 0;
25220 wxDateTime *arg1 = (wxDateTime *) 0 ;
25221 int arg2 ;
25222 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25223 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25224 bool result;
25225 void *argp1 = 0 ;
25226 int res1 = 0 ;
25227 int val2 ;
25228 int ecode2 = 0 ;
25229 int val3 ;
25230 int ecode3 = 0 ;
25231 int val4 ;
25232 int ecode4 = 0 ;
25233 PyObject * obj0 = 0 ;
25234 PyObject * obj1 = 0 ;
25235 PyObject * obj2 = 0 ;
25236 PyObject * obj3 = 0 ;
25237 char * kwnames[] = {
25238 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25239 };
25240
25241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25243 if (!SWIG_IsOK(res1)) {
25244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25245 }
25246 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25247 ecode2 = SWIG_AsVal_int(obj1, &val2);
25248 if (!SWIG_IsOK(ecode2)) {
25249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25250 }
25251 arg2 = static_cast< int >(val2);
25252 if (obj2) {
25253 ecode3 = SWIG_AsVal_int(obj2, &val3);
25254 if (!SWIG_IsOK(ecode3)) {
25255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25256 }
25257 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25258 }
25259 if (obj3) {
25260 ecode4 = SWIG_AsVal_int(obj3, &val4);
25261 if (!SWIG_IsOK(ecode4)) {
25262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25263 }
25264 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25265 }
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25269 wxPyEndAllowThreads(__tstate);
25270 if (PyErr_Occurred()) SWIG_fail;
25271 }
25272 {
25273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25274 }
25275 return resultobj;
25276 fail:
25277 return NULL;
25278 }
25279
25280
25281 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25282 PyObject *resultobj = 0;
25283 wxDateTime *arg1 = (wxDateTime *) 0 ;
25284 int arg2 ;
25285 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25286 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25287 wxDateTime result;
25288 void *argp1 = 0 ;
25289 int res1 = 0 ;
25290 int val2 ;
25291 int ecode2 = 0 ;
25292 int val3 ;
25293 int ecode3 = 0 ;
25294 int val4 ;
25295 int ecode4 = 0 ;
25296 PyObject * obj0 = 0 ;
25297 PyObject * obj1 = 0 ;
25298 PyObject * obj2 = 0 ;
25299 PyObject * obj3 = 0 ;
25300 char * kwnames[] = {
25301 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25302 };
25303
25304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25306 if (!SWIG_IsOK(res1)) {
25307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25308 }
25309 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25310 ecode2 = SWIG_AsVal_int(obj1, &val2);
25311 if (!SWIG_IsOK(ecode2)) {
25312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25313 }
25314 arg2 = static_cast< int >(val2);
25315 if (obj2) {
25316 ecode3 = SWIG_AsVal_int(obj2, &val3);
25317 if (!SWIG_IsOK(ecode3)) {
25318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25319 }
25320 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25321 }
25322 if (obj3) {
25323 ecode4 = SWIG_AsVal_int(obj3, &val4);
25324 if (!SWIG_IsOK(ecode4)) {
25325 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25326 }
25327 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25328 }
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 result = (arg1)->GetWeek(arg2,arg3,arg4);
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25336 return resultobj;
25337 fail:
25338 return NULL;
25339 }
25340
25341
25342 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25343 PyObject *resultobj = 0;
25344 int arg1 ;
25345 int arg2 ;
25346 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25347 wxDateTime result;
25348 int val1 ;
25349 int ecode1 = 0 ;
25350 int val2 ;
25351 int ecode2 = 0 ;
25352 int val3 ;
25353 int ecode3 = 0 ;
25354 PyObject * obj0 = 0 ;
25355 PyObject * obj1 = 0 ;
25356 PyObject * obj2 = 0 ;
25357 char * kwnames[] = {
25358 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25359 };
25360
25361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25362 ecode1 = SWIG_AsVal_int(obj0, &val1);
25363 if (!SWIG_IsOK(ecode1)) {
25364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25365 }
25366 arg1 = static_cast< int >(val1);
25367 ecode2 = SWIG_AsVal_int(obj1, &val2);
25368 if (!SWIG_IsOK(ecode2)) {
25369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25370 }
25371 arg2 = static_cast< int >(val2);
25372 if (obj2) {
25373 ecode3 = SWIG_AsVal_int(obj2, &val3);
25374 if (!SWIG_IsOK(ecode3)) {
25375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25376 }
25377 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25386 return resultobj;
25387 fail:
25388 return NULL;
25389 }
25390
25391
25392 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25393 PyObject *resultobj = 0;
25394 wxDateTime *arg1 = (wxDateTime *) 0 ;
25395 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25396 int arg3 = (int) wxDateTime::Inv_Year ;
25397 wxDateTime *result = 0 ;
25398 void *argp1 = 0 ;
25399 int res1 = 0 ;
25400 int val2 ;
25401 int ecode2 = 0 ;
25402 int val3 ;
25403 int ecode3 = 0 ;
25404 PyObject * obj0 = 0 ;
25405 PyObject * obj1 = 0 ;
25406 PyObject * obj2 = 0 ;
25407 char * kwnames[] = {
25408 (char *) "self",(char *) "month",(char *) "year", NULL
25409 };
25410
25411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25413 if (!SWIG_IsOK(res1)) {
25414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25415 }
25416 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25417 if (obj1) {
25418 ecode2 = SWIG_AsVal_int(obj1, &val2);
25419 if (!SWIG_IsOK(ecode2)) {
25420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25421 }
25422 arg2 = static_cast< wxDateTime::Month >(val2);
25423 }
25424 if (obj2) {
25425 ecode3 = SWIG_AsVal_int(obj2, &val3);
25426 if (!SWIG_IsOK(ecode3)) {
25427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25428 }
25429 arg3 = static_cast< int >(val3);
25430 }
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 {
25434 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25435 result = (wxDateTime *) &_result_ref;
25436 }
25437 wxPyEndAllowThreads(__tstate);
25438 if (PyErr_Occurred()) SWIG_fail;
25439 }
25440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25441 return resultobj;
25442 fail:
25443 return NULL;
25444 }
25445
25446
25447 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25448 PyObject *resultobj = 0;
25449 wxDateTime *arg1 = (wxDateTime *) 0 ;
25450 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25451 int arg3 = (int) wxDateTime::Inv_Year ;
25452 wxDateTime result;
25453 void *argp1 = 0 ;
25454 int res1 = 0 ;
25455 int val2 ;
25456 int ecode2 = 0 ;
25457 int val3 ;
25458 int ecode3 = 0 ;
25459 PyObject * obj0 = 0 ;
25460 PyObject * obj1 = 0 ;
25461 PyObject * obj2 = 0 ;
25462 char * kwnames[] = {
25463 (char *) "self",(char *) "month",(char *) "year", NULL
25464 };
25465
25466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25468 if (!SWIG_IsOK(res1)) {
25469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25470 }
25471 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25472 if (obj1) {
25473 ecode2 = SWIG_AsVal_int(obj1, &val2);
25474 if (!SWIG_IsOK(ecode2)) {
25475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25476 }
25477 arg2 = static_cast< wxDateTime::Month >(val2);
25478 }
25479 if (obj2) {
25480 ecode3 = SWIG_AsVal_int(obj2, &val3);
25481 if (!SWIG_IsOK(ecode3)) {
25482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25483 }
25484 arg3 = static_cast< int >(val3);
25485 }
25486 {
25487 PyThreadState* __tstate = wxPyBeginAllowThreads();
25488 result = (arg1)->GetLastMonthDay(arg2,arg3);
25489 wxPyEndAllowThreads(__tstate);
25490 if (PyErr_Occurred()) SWIG_fail;
25491 }
25492 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25500 PyObject *resultobj = 0;
25501 wxDateTime *arg1 = (wxDateTime *) 0 ;
25502 int arg2 ;
25503 wxDateTime *result = 0 ;
25504 void *argp1 = 0 ;
25505 int res1 = 0 ;
25506 int val2 ;
25507 int ecode2 = 0 ;
25508 PyObject * obj0 = 0 ;
25509 PyObject * obj1 = 0 ;
25510 char * kwnames[] = {
25511 (char *) "self",(char *) "yday", NULL
25512 };
25513
25514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25516 if (!SWIG_IsOK(res1)) {
25517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25518 }
25519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25520 ecode2 = SWIG_AsVal_int(obj1, &val2);
25521 if (!SWIG_IsOK(ecode2)) {
25522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25523 }
25524 arg2 = static_cast< int >(val2);
25525 {
25526 PyThreadState* __tstate = wxPyBeginAllowThreads();
25527 {
25528 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25529 result = (wxDateTime *) &_result_ref;
25530 }
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25535 return resultobj;
25536 fail:
25537 return NULL;
25538 }
25539
25540
25541 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25542 PyObject *resultobj = 0;
25543 wxDateTime *arg1 = (wxDateTime *) 0 ;
25544 int arg2 ;
25545 wxDateTime result;
25546 void *argp1 = 0 ;
25547 int res1 = 0 ;
25548 int val2 ;
25549 int ecode2 = 0 ;
25550 PyObject * obj0 = 0 ;
25551 PyObject * obj1 = 0 ;
25552 char * kwnames[] = {
25553 (char *) "self",(char *) "yday", NULL
25554 };
25555
25556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25558 if (!SWIG_IsOK(res1)) {
25559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25560 }
25561 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25562 ecode2 = SWIG_AsVal_int(obj1, &val2);
25563 if (!SWIG_IsOK(ecode2)) {
25564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25565 }
25566 arg2 = static_cast< int >(val2);
25567 {
25568 PyThreadState* __tstate = wxPyBeginAllowThreads();
25569 result = (arg1)->GetYearDay(arg2);
25570 wxPyEndAllowThreads(__tstate);
25571 if (PyErr_Occurred()) SWIG_fail;
25572 }
25573 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25574 return resultobj;
25575 fail:
25576 return NULL;
25577 }
25578
25579
25580 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25581 PyObject *resultobj = 0;
25582 wxDateTime *arg1 = (wxDateTime *) 0 ;
25583 double result;
25584 void *argp1 = 0 ;
25585 int res1 = 0 ;
25586 PyObject *swig_obj[1] ;
25587
25588 if (!args) SWIG_fail;
25589 swig_obj[0] = args;
25590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25591 if (!SWIG_IsOK(res1)) {
25592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25593 }
25594 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25595 {
25596 PyThreadState* __tstate = wxPyBeginAllowThreads();
25597 result = (double)(arg1)->GetJulianDayNumber();
25598 wxPyEndAllowThreads(__tstate);
25599 if (PyErr_Occurred()) SWIG_fail;
25600 }
25601 resultobj = SWIG_From_double(static_cast< double >(result));
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25609 PyObject *resultobj = 0;
25610 wxDateTime *arg1 = (wxDateTime *) 0 ;
25611 double result;
25612 void *argp1 = 0 ;
25613 int res1 = 0 ;
25614 PyObject *swig_obj[1] ;
25615
25616 if (!args) SWIG_fail;
25617 swig_obj[0] = args;
25618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25619 if (!SWIG_IsOK(res1)) {
25620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25621 }
25622 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25623 {
25624 PyThreadState* __tstate = wxPyBeginAllowThreads();
25625 result = (double)(arg1)->GetJDN();
25626 wxPyEndAllowThreads(__tstate);
25627 if (PyErr_Occurred()) SWIG_fail;
25628 }
25629 resultobj = SWIG_From_double(static_cast< double >(result));
25630 return resultobj;
25631 fail:
25632 return NULL;
25633 }
25634
25635
25636 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25637 PyObject *resultobj = 0;
25638 wxDateTime *arg1 = (wxDateTime *) 0 ;
25639 double result;
25640 void *argp1 = 0 ;
25641 int res1 = 0 ;
25642 PyObject *swig_obj[1] ;
25643
25644 if (!args) SWIG_fail;
25645 swig_obj[0] = args;
25646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25647 if (!SWIG_IsOK(res1)) {
25648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25649 }
25650 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25651 {
25652 PyThreadState* __tstate = wxPyBeginAllowThreads();
25653 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25654 wxPyEndAllowThreads(__tstate);
25655 if (PyErr_Occurred()) SWIG_fail;
25656 }
25657 resultobj = SWIG_From_double(static_cast< double >(result));
25658 return resultobj;
25659 fail:
25660 return NULL;
25661 }
25662
25663
25664 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25665 PyObject *resultobj = 0;
25666 wxDateTime *arg1 = (wxDateTime *) 0 ;
25667 double result;
25668 void *argp1 = 0 ;
25669 int res1 = 0 ;
25670 PyObject *swig_obj[1] ;
25671
25672 if (!args) SWIG_fail;
25673 swig_obj[0] = args;
25674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25675 if (!SWIG_IsOK(res1)) {
25676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25677 }
25678 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25679 {
25680 PyThreadState* __tstate = wxPyBeginAllowThreads();
25681 result = (double)(arg1)->GetMJD();
25682 wxPyEndAllowThreads(__tstate);
25683 if (PyErr_Occurred()) SWIG_fail;
25684 }
25685 resultobj = SWIG_From_double(static_cast< double >(result));
25686 return resultobj;
25687 fail:
25688 return NULL;
25689 }
25690
25691
25692 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25693 PyObject *resultobj = 0;
25694 wxDateTime *arg1 = (wxDateTime *) 0 ;
25695 double result;
25696 void *argp1 = 0 ;
25697 int res1 = 0 ;
25698 PyObject *swig_obj[1] ;
25699
25700 if (!args) SWIG_fail;
25701 swig_obj[0] = args;
25702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25703 if (!SWIG_IsOK(res1)) {
25704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25705 }
25706 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25707 {
25708 PyThreadState* __tstate = wxPyBeginAllowThreads();
25709 result = (double)(arg1)->GetRataDie();
25710 wxPyEndAllowThreads(__tstate);
25711 if (PyErr_Occurred()) SWIG_fail;
25712 }
25713 resultobj = SWIG_From_double(static_cast< double >(result));
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25721 PyObject *resultobj = 0;
25722 wxDateTime *arg1 = (wxDateTime *) 0 ;
25723 wxDateTime::TimeZone *arg2 = 0 ;
25724 bool arg3 = (bool) false ;
25725 wxDateTime result;
25726 void *argp1 = 0 ;
25727 int res1 = 0 ;
25728 bool temp2 = false ;
25729 bool val3 ;
25730 int ecode3 = 0 ;
25731 PyObject * obj0 = 0 ;
25732 PyObject * obj1 = 0 ;
25733 PyObject * obj2 = 0 ;
25734 char * kwnames[] = {
25735 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25736 };
25737
25738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25740 if (!SWIG_IsOK(res1)) {
25741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25742 }
25743 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25744 {
25745 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25746 temp2 = true;
25747 }
25748 if (obj2) {
25749 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25750 if (!SWIG_IsOK(ecode3)) {
25751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25752 }
25753 arg3 = static_cast< bool >(val3);
25754 }
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25758 wxPyEndAllowThreads(__tstate);
25759 if (PyErr_Occurred()) SWIG_fail;
25760 }
25761 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25762 {
25763 if (temp2) delete arg2;
25764 }
25765 return resultobj;
25766 fail:
25767 {
25768 if (temp2) delete arg2;
25769 }
25770 return NULL;
25771 }
25772
25773
25774 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25775 PyObject *resultobj = 0;
25776 wxDateTime *arg1 = (wxDateTime *) 0 ;
25777 wxDateTime::TimeZone *arg2 = 0 ;
25778 bool arg3 = (bool) false ;
25779 wxDateTime *result = 0 ;
25780 void *argp1 = 0 ;
25781 int res1 = 0 ;
25782 bool temp2 = false ;
25783 bool val3 ;
25784 int ecode3 = 0 ;
25785 PyObject * obj0 = 0 ;
25786 PyObject * obj1 = 0 ;
25787 PyObject * obj2 = 0 ;
25788 char * kwnames[] = {
25789 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25790 };
25791
25792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25794 if (!SWIG_IsOK(res1)) {
25795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25796 }
25797 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25798 {
25799 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25800 temp2 = true;
25801 }
25802 if (obj2) {
25803 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25804 if (!SWIG_IsOK(ecode3)) {
25805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25806 }
25807 arg3 = static_cast< bool >(val3);
25808 }
25809 {
25810 PyThreadState* __tstate = wxPyBeginAllowThreads();
25811 {
25812 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25813 result = (wxDateTime *) &_result_ref;
25814 }
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25819 {
25820 if (temp2) delete arg2;
25821 }
25822 return resultobj;
25823 fail:
25824 {
25825 if (temp2) delete arg2;
25826 }
25827 return NULL;
25828 }
25829
25830
25831 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25832 PyObject *resultobj = 0;
25833 wxDateTime *arg1 = (wxDateTime *) 0 ;
25834 wxDateTime::TimeZone *arg2 = 0 ;
25835 bool arg3 = (bool) false ;
25836 wxDateTime result;
25837 void *argp1 = 0 ;
25838 int res1 = 0 ;
25839 bool temp2 = false ;
25840 bool val3 ;
25841 int ecode3 = 0 ;
25842 PyObject * obj0 = 0 ;
25843 PyObject * obj1 = 0 ;
25844 PyObject * obj2 = 0 ;
25845 char * kwnames[] = {
25846 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25847 };
25848
25849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25851 if (!SWIG_IsOK(res1)) {
25852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25853 }
25854 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25855 {
25856 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25857 temp2 = true;
25858 }
25859 if (obj2) {
25860 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25861 if (!SWIG_IsOK(ecode3)) {
25862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25863 }
25864 arg3 = static_cast< bool >(val3);
25865 }
25866 {
25867 PyThreadState* __tstate = wxPyBeginAllowThreads();
25868 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25869 wxPyEndAllowThreads(__tstate);
25870 if (PyErr_Occurred()) SWIG_fail;
25871 }
25872 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25873 {
25874 if (temp2) delete arg2;
25875 }
25876 return resultobj;
25877 fail:
25878 {
25879 if (temp2) delete arg2;
25880 }
25881 return NULL;
25882 }
25883
25884
25885 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25886 PyObject *resultobj = 0;
25887 wxDateTime *arg1 = (wxDateTime *) 0 ;
25888 wxDateTime::TimeZone *arg2 = 0 ;
25889 bool arg3 = (bool) false ;
25890 wxDateTime *result = 0 ;
25891 void *argp1 = 0 ;
25892 int res1 = 0 ;
25893 bool temp2 = false ;
25894 bool val3 ;
25895 int ecode3 = 0 ;
25896 PyObject * obj0 = 0 ;
25897 PyObject * obj1 = 0 ;
25898 PyObject * obj2 = 0 ;
25899 char * kwnames[] = {
25900 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25901 };
25902
25903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25905 if (!SWIG_IsOK(res1)) {
25906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25907 }
25908 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25909 {
25910 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25911 temp2 = true;
25912 }
25913 if (obj2) {
25914 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25915 if (!SWIG_IsOK(ecode3)) {
25916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25917 }
25918 arg3 = static_cast< bool >(val3);
25919 }
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 {
25923 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25924 result = (wxDateTime *) &_result_ref;
25925 }
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25930 {
25931 if (temp2) delete arg2;
25932 }
25933 return resultobj;
25934 fail:
25935 {
25936 if (temp2) delete arg2;
25937 }
25938 return NULL;
25939 }
25940
25941
25942 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25943 PyObject *resultobj = 0;
25944 wxDateTime *arg1 = (wxDateTime *) 0 ;
25945 bool arg2 = (bool) false ;
25946 wxDateTime result;
25947 void *argp1 = 0 ;
25948 int res1 = 0 ;
25949 bool val2 ;
25950 int ecode2 = 0 ;
25951 PyObject * obj0 = 0 ;
25952 PyObject * obj1 = 0 ;
25953 char * kwnames[] = {
25954 (char *) "self",(char *) "noDST", NULL
25955 };
25956
25957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25959 if (!SWIG_IsOK(res1)) {
25960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25961 }
25962 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25963 if (obj1) {
25964 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25965 if (!SWIG_IsOK(ecode2)) {
25966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25967 }
25968 arg2 = static_cast< bool >(val2);
25969 }
25970 {
25971 PyThreadState* __tstate = wxPyBeginAllowThreads();
25972 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25973 wxPyEndAllowThreads(__tstate);
25974 if (PyErr_Occurred()) SWIG_fail;
25975 }
25976 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25977 return resultobj;
25978 fail:
25979 return NULL;
25980 }
25981
25982
25983 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25984 PyObject *resultobj = 0;
25985 wxDateTime *arg1 = (wxDateTime *) 0 ;
25986 bool arg2 = (bool) false ;
25987 wxDateTime *result = 0 ;
25988 void *argp1 = 0 ;
25989 int res1 = 0 ;
25990 bool val2 ;
25991 int ecode2 = 0 ;
25992 PyObject * obj0 = 0 ;
25993 PyObject * obj1 = 0 ;
25994 char * kwnames[] = {
25995 (char *) "self",(char *) "noDST", NULL
25996 };
25997
25998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26002 }
26003 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26004 if (obj1) {
26005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26006 if (!SWIG_IsOK(ecode2)) {
26007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
26008 }
26009 arg2 = static_cast< bool >(val2);
26010 }
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 {
26014 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
26015 result = (wxDateTime *) &_result_ref;
26016 }
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj = 0;
26029 wxDateTime *arg1 = (wxDateTime *) 0 ;
26030 bool arg2 = (bool) false ;
26031 wxDateTime result;
26032 void *argp1 = 0 ;
26033 int res1 = 0 ;
26034 bool val2 ;
26035 int ecode2 = 0 ;
26036 PyObject * obj0 = 0 ;
26037 PyObject * obj1 = 0 ;
26038 char * kwnames[] = {
26039 (char *) "self",(char *) "noDST", NULL
26040 };
26041
26042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26044 if (!SWIG_IsOK(res1)) {
26045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26046 }
26047 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26048 if (obj1) {
26049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26050 if (!SWIG_IsOK(ecode2)) {
26051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26052 }
26053 arg2 = static_cast< bool >(val2);
26054 }
26055 {
26056 PyThreadState* __tstate = wxPyBeginAllowThreads();
26057 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26058 wxPyEndAllowThreads(__tstate);
26059 if (PyErr_Occurred()) SWIG_fail;
26060 }
26061 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26062 return resultobj;
26063 fail:
26064 return NULL;
26065 }
26066
26067
26068 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26069 PyObject *resultobj = 0;
26070 wxDateTime *arg1 = (wxDateTime *) 0 ;
26071 bool arg2 = (bool) false ;
26072 wxDateTime *result = 0 ;
26073 void *argp1 = 0 ;
26074 int res1 = 0 ;
26075 bool val2 ;
26076 int ecode2 = 0 ;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char * kwnames[] = {
26080 (char *) "self",(char *) "noDST", NULL
26081 };
26082
26083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26085 if (!SWIG_IsOK(res1)) {
26086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26087 }
26088 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26089 if (obj1) {
26090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26091 if (!SWIG_IsOK(ecode2)) {
26092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26093 }
26094 arg2 = static_cast< bool >(val2);
26095 }
26096 {
26097 PyThreadState* __tstate = wxPyBeginAllowThreads();
26098 {
26099 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26100 result = (wxDateTime *) &_result_ref;
26101 }
26102 wxPyEndAllowThreads(__tstate);
26103 if (PyErr_Occurred()) SWIG_fail;
26104 }
26105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26106 return resultobj;
26107 fail:
26108 return NULL;
26109 }
26110
26111
26112 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26113 PyObject *resultobj = 0;
26114 wxDateTime *arg1 = (wxDateTime *) 0 ;
26115 bool arg2 = (bool) false ;
26116 wxDateTime result;
26117 void *argp1 = 0 ;
26118 int res1 = 0 ;
26119 bool val2 ;
26120 int ecode2 = 0 ;
26121 PyObject * obj0 = 0 ;
26122 PyObject * obj1 = 0 ;
26123 char * kwnames[] = {
26124 (char *) "self",(char *) "noDST", NULL
26125 };
26126
26127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26129 if (!SWIG_IsOK(res1)) {
26130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26131 }
26132 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26133 if (obj1) {
26134 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26135 if (!SWIG_IsOK(ecode2)) {
26136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26137 }
26138 arg2 = static_cast< bool >(val2);
26139 }
26140 {
26141 PyThreadState* __tstate = wxPyBeginAllowThreads();
26142 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26143 wxPyEndAllowThreads(__tstate);
26144 if (PyErr_Occurred()) SWIG_fail;
26145 }
26146 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26154 PyObject *resultobj = 0;
26155 wxDateTime *arg1 = (wxDateTime *) 0 ;
26156 bool arg2 = (bool) false ;
26157 wxDateTime *result = 0 ;
26158 void *argp1 = 0 ;
26159 int res1 = 0 ;
26160 bool val2 ;
26161 int ecode2 = 0 ;
26162 PyObject * obj0 = 0 ;
26163 PyObject * obj1 = 0 ;
26164 char * kwnames[] = {
26165 (char *) "self",(char *) "noDST", NULL
26166 };
26167
26168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26172 }
26173 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26174 if (obj1) {
26175 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26176 if (!SWIG_IsOK(ecode2)) {
26177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26178 }
26179 arg2 = static_cast< bool >(val2);
26180 }
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 {
26184 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26185 result = (wxDateTime *) &_result_ref;
26186 }
26187 wxPyEndAllowThreads(__tstate);
26188 if (PyErr_Occurred()) SWIG_fail;
26189 }
26190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26191 return resultobj;
26192 fail:
26193 return NULL;
26194 }
26195
26196
26197 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26198 PyObject *resultobj = 0;
26199 wxDateTime *arg1 = (wxDateTime *) 0 ;
26200 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26201 int result;
26202 void *argp1 = 0 ;
26203 int res1 = 0 ;
26204 int val2 ;
26205 int ecode2 = 0 ;
26206 PyObject * obj0 = 0 ;
26207 PyObject * obj1 = 0 ;
26208 char * kwnames[] = {
26209 (char *) "self",(char *) "country", NULL
26210 };
26211
26212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26214 if (!SWIG_IsOK(res1)) {
26215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26216 }
26217 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26218 if (obj1) {
26219 ecode2 = SWIG_AsVal_int(obj1, &val2);
26220 if (!SWIG_IsOK(ecode2)) {
26221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26222 }
26223 arg2 = static_cast< wxDateTime::Country >(val2);
26224 }
26225 {
26226 PyThreadState* __tstate = wxPyBeginAllowThreads();
26227 result = (int)(arg1)->IsDST(arg2);
26228 wxPyEndAllowThreads(__tstate);
26229 if (PyErr_Occurred()) SWIG_fail;
26230 }
26231 resultobj = SWIG_From_int(static_cast< int >(result));
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26239 PyObject *resultobj = 0;
26240 wxDateTime *arg1 = (wxDateTime *) 0 ;
26241 bool result;
26242 void *argp1 = 0 ;
26243 int res1 = 0 ;
26244 PyObject *swig_obj[1] ;
26245
26246 if (!args) SWIG_fail;
26247 swig_obj[0] = args;
26248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26249 if (!SWIG_IsOK(res1)) {
26250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26251 }
26252 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26253 {
26254 PyThreadState* __tstate = wxPyBeginAllowThreads();
26255 result = (bool)((wxDateTime const *)arg1)->IsValid();
26256 wxPyEndAllowThreads(__tstate);
26257 if (PyErr_Occurred()) SWIG_fail;
26258 }
26259 {
26260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26261 }
26262 return resultobj;
26263 fail:
26264 return NULL;
26265 }
26266
26267
26268 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26269 PyObject *resultobj = 0;
26270 wxDateTime *arg1 = (wxDateTime *) 0 ;
26271 time_t result;
26272 void *argp1 = 0 ;
26273 int res1 = 0 ;
26274 PyObject *swig_obj[1] ;
26275
26276 if (!args) SWIG_fail;
26277 swig_obj[0] = args;
26278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26279 if (!SWIG_IsOK(res1)) {
26280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26281 }
26282 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26283 {
26284 PyThreadState* __tstate = wxPyBeginAllowThreads();
26285 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26290 return resultobj;
26291 fail:
26292 return NULL;
26293 }
26294
26295
26296 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26297 PyObject *resultobj = 0;
26298 wxDateTime *arg1 = (wxDateTime *) 0 ;
26299 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26300 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26301 int result;
26302 void *argp1 = 0 ;
26303 int res1 = 0 ;
26304 bool temp2 = false ;
26305 PyObject * obj0 = 0 ;
26306 PyObject * obj1 = 0 ;
26307 char * kwnames[] = {
26308 (char *) "self",(char *) "tz", NULL
26309 };
26310
26311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26313 if (!SWIG_IsOK(res1)) {
26314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26315 }
26316 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26317 if (obj1) {
26318 {
26319 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26320 temp2 = true;
26321 }
26322 }
26323 {
26324 PyThreadState* __tstate = wxPyBeginAllowThreads();
26325 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26326 wxPyEndAllowThreads(__tstate);
26327 if (PyErr_Occurred()) SWIG_fail;
26328 }
26329 resultobj = SWIG_From_int(static_cast< int >(result));
26330 {
26331 if (temp2) delete arg2;
26332 }
26333 return resultobj;
26334 fail:
26335 {
26336 if (temp2) delete arg2;
26337 }
26338 return NULL;
26339 }
26340
26341
26342 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26343 PyObject *resultobj = 0;
26344 wxDateTime *arg1 = (wxDateTime *) 0 ;
26345 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26346 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26347 wxDateTime::Month result;
26348 void *argp1 = 0 ;
26349 int res1 = 0 ;
26350 bool temp2 = false ;
26351 PyObject * obj0 = 0 ;
26352 PyObject * obj1 = 0 ;
26353 char * kwnames[] = {
26354 (char *) "self",(char *) "tz", NULL
26355 };
26356
26357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26359 if (!SWIG_IsOK(res1)) {
26360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26361 }
26362 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26363 if (obj1) {
26364 {
26365 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26366 temp2 = true;
26367 }
26368 }
26369 {
26370 PyThreadState* __tstate = wxPyBeginAllowThreads();
26371 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26372 wxPyEndAllowThreads(__tstate);
26373 if (PyErr_Occurred()) SWIG_fail;
26374 }
26375 resultobj = SWIG_From_int(static_cast< int >(result));
26376 {
26377 if (temp2) delete arg2;
26378 }
26379 return resultobj;
26380 fail:
26381 {
26382 if (temp2) delete arg2;
26383 }
26384 return NULL;
26385 }
26386
26387
26388 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26389 PyObject *resultobj = 0;
26390 wxDateTime *arg1 = (wxDateTime *) 0 ;
26391 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26392 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26393 int result;
26394 void *argp1 = 0 ;
26395 int res1 = 0 ;
26396 bool temp2 = false ;
26397 PyObject * obj0 = 0 ;
26398 PyObject * obj1 = 0 ;
26399 char * kwnames[] = {
26400 (char *) "self",(char *) "tz", NULL
26401 };
26402
26403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26405 if (!SWIG_IsOK(res1)) {
26406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26407 }
26408 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26409 if (obj1) {
26410 {
26411 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26412 temp2 = true;
26413 }
26414 }
26415 {
26416 PyThreadState* __tstate = wxPyBeginAllowThreads();
26417 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26418 wxPyEndAllowThreads(__tstate);
26419 if (PyErr_Occurred()) SWIG_fail;
26420 }
26421 resultobj = SWIG_From_int(static_cast< int >(result));
26422 {
26423 if (temp2) delete arg2;
26424 }
26425 return resultobj;
26426 fail:
26427 {
26428 if (temp2) delete arg2;
26429 }
26430 return NULL;
26431 }
26432
26433
26434 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26435 PyObject *resultobj = 0;
26436 wxDateTime *arg1 = (wxDateTime *) 0 ;
26437 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26438 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26439 wxDateTime::WeekDay result;
26440 void *argp1 = 0 ;
26441 int res1 = 0 ;
26442 bool temp2 = false ;
26443 PyObject * obj0 = 0 ;
26444 PyObject * obj1 = 0 ;
26445 char * kwnames[] = {
26446 (char *) "self",(char *) "tz", NULL
26447 };
26448
26449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26451 if (!SWIG_IsOK(res1)) {
26452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26453 }
26454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26455 if (obj1) {
26456 {
26457 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26458 temp2 = true;
26459 }
26460 }
26461 {
26462 PyThreadState* __tstate = wxPyBeginAllowThreads();
26463 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26464 wxPyEndAllowThreads(__tstate);
26465 if (PyErr_Occurred()) SWIG_fail;
26466 }
26467 resultobj = SWIG_From_int(static_cast< int >(result));
26468 {
26469 if (temp2) delete arg2;
26470 }
26471 return resultobj;
26472 fail:
26473 {
26474 if (temp2) delete arg2;
26475 }
26476 return NULL;
26477 }
26478
26479
26480 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26481 PyObject *resultobj = 0;
26482 wxDateTime *arg1 = (wxDateTime *) 0 ;
26483 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26484 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26485 int result;
26486 void *argp1 = 0 ;
26487 int res1 = 0 ;
26488 bool temp2 = false ;
26489 PyObject * obj0 = 0 ;
26490 PyObject * obj1 = 0 ;
26491 char * kwnames[] = {
26492 (char *) "self",(char *) "tz", NULL
26493 };
26494
26495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26497 if (!SWIG_IsOK(res1)) {
26498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26499 }
26500 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26501 if (obj1) {
26502 {
26503 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26504 temp2 = true;
26505 }
26506 }
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 resultobj = SWIG_From_int(static_cast< int >(result));
26514 {
26515 if (temp2) delete arg2;
26516 }
26517 return resultobj;
26518 fail:
26519 {
26520 if (temp2) delete arg2;
26521 }
26522 return NULL;
26523 }
26524
26525
26526 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26527 PyObject *resultobj = 0;
26528 wxDateTime *arg1 = (wxDateTime *) 0 ;
26529 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26530 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26531 int result;
26532 void *argp1 = 0 ;
26533 int res1 = 0 ;
26534 bool temp2 = false ;
26535 PyObject * obj0 = 0 ;
26536 PyObject * obj1 = 0 ;
26537 char * kwnames[] = {
26538 (char *) "self",(char *) "tz", NULL
26539 };
26540
26541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26543 if (!SWIG_IsOK(res1)) {
26544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26545 }
26546 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26547 if (obj1) {
26548 {
26549 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26550 temp2 = true;
26551 }
26552 }
26553 {
26554 PyThreadState* __tstate = wxPyBeginAllowThreads();
26555 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 resultobj = SWIG_From_int(static_cast< int >(result));
26560 {
26561 if (temp2) delete arg2;
26562 }
26563 return resultobj;
26564 fail:
26565 {
26566 if (temp2) delete arg2;
26567 }
26568 return NULL;
26569 }
26570
26571
26572 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26573 PyObject *resultobj = 0;
26574 wxDateTime *arg1 = (wxDateTime *) 0 ;
26575 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26576 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26577 int result;
26578 void *argp1 = 0 ;
26579 int res1 = 0 ;
26580 bool temp2 = false ;
26581 PyObject * obj0 = 0 ;
26582 PyObject * obj1 = 0 ;
26583 char * kwnames[] = {
26584 (char *) "self",(char *) "tz", NULL
26585 };
26586
26587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26589 if (!SWIG_IsOK(res1)) {
26590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26591 }
26592 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26593 if (obj1) {
26594 {
26595 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26596 temp2 = true;
26597 }
26598 }
26599 {
26600 PyThreadState* __tstate = wxPyBeginAllowThreads();
26601 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26602 wxPyEndAllowThreads(__tstate);
26603 if (PyErr_Occurred()) SWIG_fail;
26604 }
26605 resultobj = SWIG_From_int(static_cast< int >(result));
26606 {
26607 if (temp2) delete arg2;
26608 }
26609 return resultobj;
26610 fail:
26611 {
26612 if (temp2) delete arg2;
26613 }
26614 return NULL;
26615 }
26616
26617
26618 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26619 PyObject *resultobj = 0;
26620 wxDateTime *arg1 = (wxDateTime *) 0 ;
26621 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26622 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26623 int result;
26624 void *argp1 = 0 ;
26625 int res1 = 0 ;
26626 bool temp2 = false ;
26627 PyObject * obj0 = 0 ;
26628 PyObject * obj1 = 0 ;
26629 char * kwnames[] = {
26630 (char *) "self",(char *) "tz", NULL
26631 };
26632
26633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26635 if (!SWIG_IsOK(res1)) {
26636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26637 }
26638 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26639 if (obj1) {
26640 {
26641 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26642 temp2 = true;
26643 }
26644 }
26645 {
26646 PyThreadState* __tstate = wxPyBeginAllowThreads();
26647 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26648 wxPyEndAllowThreads(__tstate);
26649 if (PyErr_Occurred()) SWIG_fail;
26650 }
26651 resultobj = SWIG_From_int(static_cast< int >(result));
26652 {
26653 if (temp2) delete arg2;
26654 }
26655 return resultobj;
26656 fail:
26657 {
26658 if (temp2) delete arg2;
26659 }
26660 return NULL;
26661 }
26662
26663
26664 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26665 PyObject *resultobj = 0;
26666 wxDateTime *arg1 = (wxDateTime *) 0 ;
26667 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26668 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26669 int result;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 bool temp2 = false ;
26673 PyObject * obj0 = 0 ;
26674 PyObject * obj1 = 0 ;
26675 char * kwnames[] = {
26676 (char *) "self",(char *) "tz", NULL
26677 };
26678
26679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26681 if (!SWIG_IsOK(res1)) {
26682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26683 }
26684 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26685 if (obj1) {
26686 {
26687 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26688 temp2 = true;
26689 }
26690 }
26691 {
26692 PyThreadState* __tstate = wxPyBeginAllowThreads();
26693 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26694 wxPyEndAllowThreads(__tstate);
26695 if (PyErr_Occurred()) SWIG_fail;
26696 }
26697 resultobj = SWIG_From_int(static_cast< int >(result));
26698 {
26699 if (temp2) delete arg2;
26700 }
26701 return resultobj;
26702 fail:
26703 {
26704 if (temp2) delete arg2;
26705 }
26706 return NULL;
26707 }
26708
26709
26710 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26711 PyObject *resultobj = 0;
26712 wxDateTime *arg1 = (wxDateTime *) 0 ;
26713 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26714 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26715 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26716 int result;
26717 void *argp1 = 0 ;
26718 int res1 = 0 ;
26719 int val2 ;
26720 int ecode2 = 0 ;
26721 bool temp3 = false ;
26722 PyObject * obj0 = 0 ;
26723 PyObject * obj1 = 0 ;
26724 PyObject * obj2 = 0 ;
26725 char * kwnames[] = {
26726 (char *) "self",(char *) "flags",(char *) "tz", NULL
26727 };
26728
26729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26731 if (!SWIG_IsOK(res1)) {
26732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26733 }
26734 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26735 if (obj1) {
26736 ecode2 = SWIG_AsVal_int(obj1, &val2);
26737 if (!SWIG_IsOK(ecode2)) {
26738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26739 }
26740 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26741 }
26742 if (obj2) {
26743 {
26744 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26745 temp3 = true;
26746 }
26747 }
26748 {
26749 PyThreadState* __tstate = wxPyBeginAllowThreads();
26750 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26751 wxPyEndAllowThreads(__tstate);
26752 if (PyErr_Occurred()) SWIG_fail;
26753 }
26754 resultobj = SWIG_From_int(static_cast< int >(result));
26755 {
26756 if (temp3) delete arg3;
26757 }
26758 return resultobj;
26759 fail:
26760 {
26761 if (temp3) delete arg3;
26762 }
26763 return NULL;
26764 }
26765
26766
26767 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26768 PyObject *resultobj = 0;
26769 wxDateTime *arg1 = (wxDateTime *) 0 ;
26770 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26771 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26772 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26773 int result;
26774 void *argp1 = 0 ;
26775 int res1 = 0 ;
26776 int val2 ;
26777 int ecode2 = 0 ;
26778 bool temp3 = false ;
26779 PyObject * obj0 = 0 ;
26780 PyObject * obj1 = 0 ;
26781 PyObject * obj2 = 0 ;
26782 char * kwnames[] = {
26783 (char *) "self",(char *) "flags",(char *) "tz", NULL
26784 };
26785
26786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26788 if (!SWIG_IsOK(res1)) {
26789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26790 }
26791 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26792 if (obj1) {
26793 ecode2 = SWIG_AsVal_int(obj1, &val2);
26794 if (!SWIG_IsOK(ecode2)) {
26795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26796 }
26797 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26798 }
26799 if (obj2) {
26800 {
26801 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26802 temp3 = true;
26803 }
26804 }
26805 {
26806 PyThreadState* __tstate = wxPyBeginAllowThreads();
26807 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26808 wxPyEndAllowThreads(__tstate);
26809 if (PyErr_Occurred()) SWIG_fail;
26810 }
26811 resultobj = SWIG_From_int(static_cast< int >(result));
26812 {
26813 if (temp3) delete arg3;
26814 }
26815 return resultobj;
26816 fail:
26817 {
26818 if (temp3) delete arg3;
26819 }
26820 return NULL;
26821 }
26822
26823
26824 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj = 0;
26826 wxDateTime *arg1 = (wxDateTime *) 0 ;
26827 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26828 bool result;
26829 void *argp1 = 0 ;
26830 int res1 = 0 ;
26831 int val2 ;
26832 int ecode2 = 0 ;
26833 PyObject * obj0 = 0 ;
26834 PyObject * obj1 = 0 ;
26835 char * kwnames[] = {
26836 (char *) "self",(char *) "country", NULL
26837 };
26838
26839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26841 if (!SWIG_IsOK(res1)) {
26842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26843 }
26844 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26845 if (obj1) {
26846 ecode2 = SWIG_AsVal_int(obj1, &val2);
26847 if (!SWIG_IsOK(ecode2)) {
26848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26849 }
26850 arg2 = static_cast< wxDateTime::Country >(val2);
26851 }
26852 {
26853 PyThreadState* __tstate = wxPyBeginAllowThreads();
26854 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26855 wxPyEndAllowThreads(__tstate);
26856 if (PyErr_Occurred()) SWIG_fail;
26857 }
26858 {
26859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26860 }
26861 return resultobj;
26862 fail:
26863 return NULL;
26864 }
26865
26866
26867 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26868 PyObject *resultobj = 0;
26869 wxDateTime *arg1 = (wxDateTime *) 0 ;
26870 wxDateTime *arg2 = 0 ;
26871 bool result;
26872 void *argp1 = 0 ;
26873 int res1 = 0 ;
26874 void *argp2 = 0 ;
26875 int res2 = 0 ;
26876 PyObject * obj0 = 0 ;
26877 PyObject * obj1 = 0 ;
26878 char * kwnames[] = {
26879 (char *) "self",(char *) "datetime", NULL
26880 };
26881
26882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26884 if (!SWIG_IsOK(res1)) {
26885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26886 }
26887 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26888 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26889 if (!SWIG_IsOK(res2)) {
26890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26891 }
26892 if (!argp2) {
26893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26894 }
26895 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26896 {
26897 PyThreadState* __tstate = wxPyBeginAllowThreads();
26898 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26899 wxPyEndAllowThreads(__tstate);
26900 if (PyErr_Occurred()) SWIG_fail;
26901 }
26902 {
26903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26904 }
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj = 0;
26913 wxDateTime *arg1 = (wxDateTime *) 0 ;
26914 wxDateTime *arg2 = 0 ;
26915 bool result;
26916 void *argp1 = 0 ;
26917 int res1 = 0 ;
26918 void *argp2 = 0 ;
26919 int res2 = 0 ;
26920 PyObject * obj0 = 0 ;
26921 PyObject * obj1 = 0 ;
26922 char * kwnames[] = {
26923 (char *) "self",(char *) "datetime", NULL
26924 };
26925
26926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26928 if (!SWIG_IsOK(res1)) {
26929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26930 }
26931 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26932 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26933 if (!SWIG_IsOK(res2)) {
26934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26935 }
26936 if (!argp2) {
26937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26938 }
26939 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26940 {
26941 PyThreadState* __tstate = wxPyBeginAllowThreads();
26942 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26943 wxPyEndAllowThreads(__tstate);
26944 if (PyErr_Occurred()) SWIG_fail;
26945 }
26946 {
26947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26948 }
26949 return resultobj;
26950 fail:
26951 return NULL;
26952 }
26953
26954
26955 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26956 PyObject *resultobj = 0;
26957 wxDateTime *arg1 = (wxDateTime *) 0 ;
26958 wxDateTime *arg2 = 0 ;
26959 bool result;
26960 void *argp1 = 0 ;
26961 int res1 = 0 ;
26962 void *argp2 = 0 ;
26963 int res2 = 0 ;
26964 PyObject * obj0 = 0 ;
26965 PyObject * obj1 = 0 ;
26966 char * kwnames[] = {
26967 (char *) "self",(char *) "datetime", NULL
26968 };
26969
26970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26972 if (!SWIG_IsOK(res1)) {
26973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26974 }
26975 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26977 if (!SWIG_IsOK(res2)) {
26978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26979 }
26980 if (!argp2) {
26981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26982 }
26983 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26984 {
26985 PyThreadState* __tstate = wxPyBeginAllowThreads();
26986 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26987 wxPyEndAllowThreads(__tstate);
26988 if (PyErr_Occurred()) SWIG_fail;
26989 }
26990 {
26991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26992 }
26993 return resultobj;
26994 fail:
26995 return NULL;
26996 }
26997
26998
26999 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27000 PyObject *resultobj = 0;
27001 wxDateTime *arg1 = (wxDateTime *) 0 ;
27002 wxDateTime *arg2 = 0 ;
27003 wxDateTime *arg3 = 0 ;
27004 bool result;
27005 void *argp1 = 0 ;
27006 int res1 = 0 ;
27007 void *argp2 = 0 ;
27008 int res2 = 0 ;
27009 void *argp3 = 0 ;
27010 int res3 = 0 ;
27011 PyObject * obj0 = 0 ;
27012 PyObject * obj1 = 0 ;
27013 PyObject * obj2 = 0 ;
27014 char * kwnames[] = {
27015 (char *) "self",(char *) "t1",(char *) "t2", NULL
27016 };
27017
27018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27020 if (!SWIG_IsOK(res1)) {
27021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27022 }
27023 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27024 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27025 if (!SWIG_IsOK(res2)) {
27026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27027 }
27028 if (!argp2) {
27029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27030 }
27031 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27032 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27033 if (!SWIG_IsOK(res3)) {
27034 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27035 }
27036 if (!argp3) {
27037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27038 }
27039 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27040 {
27041 PyThreadState* __tstate = wxPyBeginAllowThreads();
27042 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 {
27047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27048 }
27049 return resultobj;
27050 fail:
27051 return NULL;
27052 }
27053
27054
27055 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27056 PyObject *resultobj = 0;
27057 wxDateTime *arg1 = (wxDateTime *) 0 ;
27058 wxDateTime *arg2 = 0 ;
27059 wxDateTime *arg3 = 0 ;
27060 bool result;
27061 void *argp1 = 0 ;
27062 int res1 = 0 ;
27063 void *argp2 = 0 ;
27064 int res2 = 0 ;
27065 void *argp3 = 0 ;
27066 int res3 = 0 ;
27067 PyObject * obj0 = 0 ;
27068 PyObject * obj1 = 0 ;
27069 PyObject * obj2 = 0 ;
27070 char * kwnames[] = {
27071 (char *) "self",(char *) "t1",(char *) "t2", NULL
27072 };
27073
27074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27076 if (!SWIG_IsOK(res1)) {
27077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27078 }
27079 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27080 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27081 if (!SWIG_IsOK(res2)) {
27082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27083 }
27084 if (!argp2) {
27085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27086 }
27087 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27088 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27089 if (!SWIG_IsOK(res3)) {
27090 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27091 }
27092 if (!argp3) {
27093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27094 }
27095 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27096 {
27097 PyThreadState* __tstate = wxPyBeginAllowThreads();
27098 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27099 wxPyEndAllowThreads(__tstate);
27100 if (PyErr_Occurred()) SWIG_fail;
27101 }
27102 {
27103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27104 }
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27112 PyObject *resultobj = 0;
27113 wxDateTime *arg1 = (wxDateTime *) 0 ;
27114 wxDateTime *arg2 = 0 ;
27115 bool result;
27116 void *argp1 = 0 ;
27117 int res1 = 0 ;
27118 void *argp2 = 0 ;
27119 int res2 = 0 ;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 char * kwnames[] = {
27123 (char *) "self",(char *) "dt", NULL
27124 };
27125
27126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27128 if (!SWIG_IsOK(res1)) {
27129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27130 }
27131 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27132 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27133 if (!SWIG_IsOK(res2)) {
27134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27135 }
27136 if (!argp2) {
27137 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27138 }
27139 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27143 wxPyEndAllowThreads(__tstate);
27144 if (PyErr_Occurred()) SWIG_fail;
27145 }
27146 {
27147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27148 }
27149 return resultobj;
27150 fail:
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27156 PyObject *resultobj = 0;
27157 wxDateTime *arg1 = (wxDateTime *) 0 ;
27158 wxDateTime *arg2 = 0 ;
27159 bool result;
27160 void *argp1 = 0 ;
27161 int res1 = 0 ;
27162 void *argp2 = 0 ;
27163 int res2 = 0 ;
27164 PyObject * obj0 = 0 ;
27165 PyObject * obj1 = 0 ;
27166 char * kwnames[] = {
27167 (char *) "self",(char *) "dt", NULL
27168 };
27169
27170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27172 if (!SWIG_IsOK(res1)) {
27173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27174 }
27175 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27176 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27177 if (!SWIG_IsOK(res2)) {
27178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27179 }
27180 if (!argp2) {
27181 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27182 }
27183 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 {
27191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27192 }
27193 return resultobj;
27194 fail:
27195 return NULL;
27196 }
27197
27198
27199 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27200 PyObject *resultobj = 0;
27201 wxDateTime *arg1 = (wxDateTime *) 0 ;
27202 wxDateTime *arg2 = 0 ;
27203 wxTimeSpan *arg3 = 0 ;
27204 bool result;
27205 void *argp1 = 0 ;
27206 int res1 = 0 ;
27207 void *argp2 = 0 ;
27208 int res2 = 0 ;
27209 void *argp3 = 0 ;
27210 int res3 = 0 ;
27211 PyObject * obj0 = 0 ;
27212 PyObject * obj1 = 0 ;
27213 PyObject * obj2 = 0 ;
27214 char * kwnames[] = {
27215 (char *) "self",(char *) "dt",(char *) "ts", NULL
27216 };
27217
27218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27220 if (!SWIG_IsOK(res1)) {
27221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27222 }
27223 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27225 if (!SWIG_IsOK(res2)) {
27226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27227 }
27228 if (!argp2) {
27229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27230 }
27231 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27232 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27233 if (!SWIG_IsOK(res3)) {
27234 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27235 }
27236 if (!argp3) {
27237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27238 }
27239 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 {
27247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27248 }
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27256 PyObject *resultobj = 0;
27257 wxDateTime *arg1 = (wxDateTime *) 0 ;
27258 wxTimeSpan *arg2 = 0 ;
27259 wxDateTime *result = 0 ;
27260 void *argp1 = 0 ;
27261 int res1 = 0 ;
27262 void *argp2 = 0 ;
27263 int res2 = 0 ;
27264 PyObject * obj0 = 0 ;
27265 PyObject * obj1 = 0 ;
27266 char * kwnames[] = {
27267 (char *) "self",(char *) "diff", NULL
27268 };
27269
27270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27272 if (!SWIG_IsOK(res1)) {
27273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27274 }
27275 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27276 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27277 if (!SWIG_IsOK(res2)) {
27278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27279 }
27280 if (!argp2) {
27281 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27282 }
27283 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 {
27287 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27288 result = (wxDateTime *) &_result_ref;
27289 }
27290 wxPyEndAllowThreads(__tstate);
27291 if (PyErr_Occurred()) SWIG_fail;
27292 }
27293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27294 return resultobj;
27295 fail:
27296 return NULL;
27297 }
27298
27299
27300 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27301 PyObject *resultobj = 0;
27302 wxDateTime *arg1 = (wxDateTime *) 0 ;
27303 wxDateSpan *arg2 = 0 ;
27304 wxDateTime *result = 0 ;
27305 void *argp1 = 0 ;
27306 int res1 = 0 ;
27307 void *argp2 = 0 ;
27308 int res2 = 0 ;
27309 PyObject * obj0 = 0 ;
27310 PyObject * obj1 = 0 ;
27311 char * kwnames[] = {
27312 (char *) "self",(char *) "diff", NULL
27313 };
27314
27315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27317 if (!SWIG_IsOK(res1)) {
27318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27319 }
27320 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27322 if (!SWIG_IsOK(res2)) {
27323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27324 }
27325 if (!argp2) {
27326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27327 }
27328 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27329 {
27330 PyThreadState* __tstate = wxPyBeginAllowThreads();
27331 {
27332 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27333 result = (wxDateTime *) &_result_ref;
27334 }
27335 wxPyEndAllowThreads(__tstate);
27336 if (PyErr_Occurred()) SWIG_fail;
27337 }
27338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27339 return resultobj;
27340 fail:
27341 return NULL;
27342 }
27343
27344
27345 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27346 PyObject *resultobj = 0;
27347 wxDateTime *arg1 = (wxDateTime *) 0 ;
27348 wxTimeSpan *arg2 = 0 ;
27349 wxDateTime *result = 0 ;
27350 void *argp1 = 0 ;
27351 int res1 = 0 ;
27352 void *argp2 = 0 ;
27353 int res2 = 0 ;
27354 PyObject * obj0 = 0 ;
27355 PyObject * obj1 = 0 ;
27356 char * kwnames[] = {
27357 (char *) "self",(char *) "diff", NULL
27358 };
27359
27360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27362 if (!SWIG_IsOK(res1)) {
27363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27364 }
27365 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27366 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27367 if (!SWIG_IsOK(res2)) {
27368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27369 }
27370 if (!argp2) {
27371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27372 }
27373 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 {
27377 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27378 result = (wxDateTime *) &_result_ref;
27379 }
27380 wxPyEndAllowThreads(__tstate);
27381 if (PyErr_Occurred()) SWIG_fail;
27382 }
27383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27384 return resultobj;
27385 fail:
27386 return NULL;
27387 }
27388
27389
27390 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27391 PyObject *resultobj = 0;
27392 wxDateTime *arg1 = (wxDateTime *) 0 ;
27393 wxDateSpan *arg2 = 0 ;
27394 wxDateTime *result = 0 ;
27395 void *argp1 = 0 ;
27396 int res1 = 0 ;
27397 void *argp2 = 0 ;
27398 int res2 = 0 ;
27399 PyObject * obj0 = 0 ;
27400 PyObject * obj1 = 0 ;
27401 char * kwnames[] = {
27402 (char *) "self",(char *) "diff", NULL
27403 };
27404
27405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27407 if (!SWIG_IsOK(res1)) {
27408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27409 }
27410 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27411 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27412 if (!SWIG_IsOK(res2)) {
27413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27414 }
27415 if (!argp2) {
27416 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27417 }
27418 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27419 {
27420 PyThreadState* __tstate = wxPyBeginAllowThreads();
27421 {
27422 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27423 result = (wxDateTime *) &_result_ref;
27424 }
27425 wxPyEndAllowThreads(__tstate);
27426 if (PyErr_Occurred()) SWIG_fail;
27427 }
27428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27429 return resultobj;
27430 fail:
27431 return NULL;
27432 }
27433
27434
27435 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27436 PyObject *resultobj = 0;
27437 wxDateTime *arg1 = (wxDateTime *) 0 ;
27438 wxDateTime *arg2 = 0 ;
27439 wxTimeSpan result;
27440 void *argp1 = 0 ;
27441 int res1 = 0 ;
27442 void *argp2 = 0 ;
27443 int res2 = 0 ;
27444 PyObject * obj0 = 0 ;
27445 PyObject * obj1 = 0 ;
27446 char * kwnames[] = {
27447 (char *) "self",(char *) "dt", NULL
27448 };
27449
27450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27452 if (!SWIG_IsOK(res1)) {
27453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27454 }
27455 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27456 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27457 if (!SWIG_IsOK(res2)) {
27458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27459 }
27460 if (!argp2) {
27461 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27462 }
27463 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27464 {
27465 PyThreadState* __tstate = wxPyBeginAllowThreads();
27466 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27467 wxPyEndAllowThreads(__tstate);
27468 if (PyErr_Occurred()) SWIG_fail;
27469 }
27470 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27471 return resultobj;
27472 fail:
27473 return NULL;
27474 }
27475
27476
27477 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27478 PyObject *resultobj = 0;
27479 wxDateTime *arg1 = (wxDateTime *) 0 ;
27480 wxTimeSpan *arg2 = 0 ;
27481 wxDateTime *result = 0 ;
27482 void *argp1 = 0 ;
27483 int res1 = 0 ;
27484 void *argp2 = 0 ;
27485 int res2 = 0 ;
27486
27487 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27489 if (!SWIG_IsOK(res1)) {
27490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27491 }
27492 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27493 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27494 if (!SWIG_IsOK(res2)) {
27495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27496 }
27497 if (!argp2) {
27498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27499 }
27500 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 {
27504 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27505 result = (wxDateTime *) &_result_ref;
27506 }
27507 wxPyEndAllowThreads(__tstate);
27508 if (PyErr_Occurred()) SWIG_fail;
27509 }
27510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27518 PyObject *resultobj = 0;
27519 wxDateTime *arg1 = (wxDateTime *) 0 ;
27520 wxDateSpan *arg2 = 0 ;
27521 wxDateTime *result = 0 ;
27522 void *argp1 = 0 ;
27523 int res1 = 0 ;
27524 void *argp2 = 0 ;
27525 int res2 = 0 ;
27526
27527 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27529 if (!SWIG_IsOK(res1)) {
27530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27531 }
27532 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27533 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27534 if (!SWIG_IsOK(res2)) {
27535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27536 }
27537 if (!argp2) {
27538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27539 }
27540 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 {
27544 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27545 result = (wxDateTime *) &_result_ref;
27546 }
27547 wxPyEndAllowThreads(__tstate);
27548 if (PyErr_Occurred()) SWIG_fail;
27549 }
27550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27551 return resultobj;
27552 fail:
27553 return NULL;
27554 }
27555
27556
27557 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27558 int argc;
27559 PyObject *argv[3];
27560
27561 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27562 --argc;
27563 if (argc == 2) {
27564 int _v = 0;
27565 {
27566 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27567 _v = SWIG_CheckState(res);
27568 }
27569 if (!_v) goto check_1;
27570 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27571 }
27572 check_1:
27573
27574 if (argc == 2) {
27575 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27576 }
27577
27578 fail:
27579 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27580 return NULL;
27581 }
27582
27583
27584 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27585 PyObject *resultobj = 0;
27586 wxDateTime *arg1 = (wxDateTime *) 0 ;
27587 wxTimeSpan *arg2 = 0 ;
27588 wxDateTime *result = 0 ;
27589 void *argp1 = 0 ;
27590 int res1 = 0 ;
27591 void *argp2 = 0 ;
27592 int res2 = 0 ;
27593
27594 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27596 if (!SWIG_IsOK(res1)) {
27597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27598 }
27599 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27600 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27601 if (!SWIG_IsOK(res2)) {
27602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27603 }
27604 if (!argp2) {
27605 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27606 }
27607 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 {
27611 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27612 result = (wxDateTime *) &_result_ref;
27613 }
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27618 return resultobj;
27619 fail:
27620 return NULL;
27621 }
27622
27623
27624 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27625 PyObject *resultobj = 0;
27626 wxDateTime *arg1 = (wxDateTime *) 0 ;
27627 wxDateSpan *arg2 = 0 ;
27628 wxDateTime *result = 0 ;
27629 void *argp1 = 0 ;
27630 int res1 = 0 ;
27631 void *argp2 = 0 ;
27632 int res2 = 0 ;
27633
27634 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27636 if (!SWIG_IsOK(res1)) {
27637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27638 }
27639 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27640 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27641 if (!SWIG_IsOK(res2)) {
27642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27643 }
27644 if (!argp2) {
27645 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27646 }
27647 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27648 {
27649 PyThreadState* __tstate = wxPyBeginAllowThreads();
27650 {
27651 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27652 result = (wxDateTime *) &_result_ref;
27653 }
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27658 return resultobj;
27659 fail:
27660 return NULL;
27661 }
27662
27663
27664 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27665 int argc;
27666 PyObject *argv[3];
27667
27668 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27669 --argc;
27670 if (argc == 2) {
27671 int _v = 0;
27672 {
27673 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27674 _v = SWIG_CheckState(res);
27675 }
27676 if (!_v) goto check_1;
27677 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27678 }
27679 check_1:
27680
27681 if (argc == 2) {
27682 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27683 }
27684
27685 fail:
27686 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27687 return NULL;
27688 }
27689
27690
27691 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27692 PyObject *resultobj = 0;
27693 wxDateTime *arg1 = (wxDateTime *) 0 ;
27694 wxTimeSpan *arg2 = 0 ;
27695 wxDateTime result;
27696 void *argp1 = 0 ;
27697 int res1 = 0 ;
27698 void *argp2 = 0 ;
27699 int res2 = 0 ;
27700
27701 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27703 if (!SWIG_IsOK(res1)) {
27704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27705 }
27706 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27707 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27708 if (!SWIG_IsOK(res2)) {
27709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27710 }
27711 if (!argp2) {
27712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27713 }
27714 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27722 return resultobj;
27723 fail:
27724 return NULL;
27725 }
27726
27727
27728 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27729 PyObject *resultobj = 0;
27730 wxDateTime *arg1 = (wxDateTime *) 0 ;
27731 wxDateSpan *arg2 = 0 ;
27732 wxDateTime result;
27733 void *argp1 = 0 ;
27734 int res1 = 0 ;
27735 void *argp2 = 0 ;
27736 int res2 = 0 ;
27737
27738 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27740 if (!SWIG_IsOK(res1)) {
27741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27742 }
27743 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27744 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27745 if (!SWIG_IsOK(res2)) {
27746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27747 }
27748 if (!argp2) {
27749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27750 }
27751 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27752 {
27753 PyThreadState* __tstate = wxPyBeginAllowThreads();
27754 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27755 wxPyEndAllowThreads(__tstate);
27756 if (PyErr_Occurred()) SWIG_fail;
27757 }
27758 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27759 return resultobj;
27760 fail:
27761 return NULL;
27762 }
27763
27764
27765 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27766 int argc;
27767 PyObject *argv[3];
27768
27769 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27770 --argc;
27771 if (argc == 2) {
27772 int _v = 0;
27773 {
27774 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27775 _v = SWIG_CheckState(res);
27776 }
27777 if (!_v) goto check_1;
27778 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27779 }
27780 check_1:
27781
27782 if (argc == 2) {
27783 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27784 }
27785
27786 fail:
27787 Py_INCREF(Py_NotImplemented);
27788 return Py_NotImplemented;
27789 }
27790
27791
27792 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27793 PyObject *resultobj = 0;
27794 wxDateTime *arg1 = (wxDateTime *) 0 ;
27795 wxDateTime *arg2 = 0 ;
27796 wxTimeSpan result;
27797 void *argp1 = 0 ;
27798 int res1 = 0 ;
27799 void *argp2 = 0 ;
27800 int res2 = 0 ;
27801
27802 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27804 if (!SWIG_IsOK(res1)) {
27805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27806 }
27807 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27808 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27809 if (!SWIG_IsOK(res2)) {
27810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27811 }
27812 if (!argp2) {
27813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27814 }
27815 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27819 wxPyEndAllowThreads(__tstate);
27820 if (PyErr_Occurred()) SWIG_fail;
27821 }
27822 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27823 return resultobj;
27824 fail:
27825 return NULL;
27826 }
27827
27828
27829 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27830 PyObject *resultobj = 0;
27831 wxDateTime *arg1 = (wxDateTime *) 0 ;
27832 wxTimeSpan *arg2 = 0 ;
27833 wxDateTime result;
27834 void *argp1 = 0 ;
27835 int res1 = 0 ;
27836 void *argp2 = 0 ;
27837 int res2 = 0 ;
27838
27839 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27841 if (!SWIG_IsOK(res1)) {
27842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27843 }
27844 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27845 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27846 if (!SWIG_IsOK(res2)) {
27847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27848 }
27849 if (!argp2) {
27850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27851 }
27852 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27856 wxPyEndAllowThreads(__tstate);
27857 if (PyErr_Occurred()) SWIG_fail;
27858 }
27859 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27867 PyObject *resultobj = 0;
27868 wxDateTime *arg1 = (wxDateTime *) 0 ;
27869 wxDateSpan *arg2 = 0 ;
27870 wxDateTime result;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 void *argp2 = 0 ;
27874 int res2 = 0 ;
27875
27876 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27880 }
27881 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27882 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27883 if (!SWIG_IsOK(res2)) {
27884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27885 }
27886 if (!argp2) {
27887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27888 }
27889 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27890 {
27891 PyThreadState* __tstate = wxPyBeginAllowThreads();
27892 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27897 return resultobj;
27898 fail:
27899 return NULL;
27900 }
27901
27902
27903 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27904 int argc;
27905 PyObject *argv[3];
27906
27907 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27908 --argc;
27909 if (argc == 2) {
27910 int _v = 0;
27911 {
27912 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27913 _v = SWIG_CheckState(res);
27914 }
27915 if (!_v) goto check_1;
27916 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27917 }
27918 check_1:
27919
27920 if (argc == 2) {
27921 int _v = 0;
27922 {
27923 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27924 _v = SWIG_CheckState(res);
27925 }
27926 if (!_v) goto check_2;
27927 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27928 }
27929 check_2:
27930
27931 if (argc == 2) {
27932 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27933 }
27934
27935 fail:
27936 Py_INCREF(Py_NotImplemented);
27937 return Py_NotImplemented;
27938 }
27939
27940
27941 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27942 PyObject *resultobj = 0;
27943 wxDateTime *arg1 = (wxDateTime *) 0 ;
27944 wxDateTime *arg2 = (wxDateTime *) 0 ;
27945 bool result;
27946 void *argp1 = 0 ;
27947 int res1 = 0 ;
27948 void *argp2 = 0 ;
27949 int res2 = 0 ;
27950 PyObject * obj0 = 0 ;
27951 PyObject * obj1 = 0 ;
27952 char * kwnames[] = {
27953 (char *) "self",(char *) "other", NULL
27954 };
27955
27956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27958 if (!SWIG_IsOK(res1)) {
27959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27960 }
27961 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27962 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27963 if (!SWIG_IsOK(res2)) {
27964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27965 }
27966 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27967 {
27968 PyThreadState* __tstate = wxPyBeginAllowThreads();
27969 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27970 wxPyEndAllowThreads(__tstate);
27971 if (PyErr_Occurred()) SWIG_fail;
27972 }
27973 {
27974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27975 }
27976 return resultobj;
27977 fail:
27978 return NULL;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27983 PyObject *resultobj = 0;
27984 wxDateTime *arg1 = (wxDateTime *) 0 ;
27985 wxDateTime *arg2 = (wxDateTime *) 0 ;
27986 bool result;
27987 void *argp1 = 0 ;
27988 int res1 = 0 ;
27989 void *argp2 = 0 ;
27990 int res2 = 0 ;
27991 PyObject * obj0 = 0 ;
27992 PyObject * obj1 = 0 ;
27993 char * kwnames[] = {
27994 (char *) "self",(char *) "other", NULL
27995 };
27996
27997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27999 if (!SWIG_IsOK(res1)) {
28000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28001 }
28002 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28004 if (!SWIG_IsOK(res2)) {
28005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28006 }
28007 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 {
28015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28016 }
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28024 PyObject *resultobj = 0;
28025 wxDateTime *arg1 = (wxDateTime *) 0 ;
28026 wxDateTime *arg2 = (wxDateTime *) 0 ;
28027 bool result;
28028 void *argp1 = 0 ;
28029 int res1 = 0 ;
28030 void *argp2 = 0 ;
28031 int res2 = 0 ;
28032 PyObject * obj0 = 0 ;
28033 PyObject * obj1 = 0 ;
28034 char * kwnames[] = {
28035 (char *) "self",(char *) "other", NULL
28036 };
28037
28038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28040 if (!SWIG_IsOK(res1)) {
28041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28042 }
28043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28044 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28045 if (!SWIG_IsOK(res2)) {
28046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28047 }
28048 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28049 {
28050 PyThreadState* __tstate = wxPyBeginAllowThreads();
28051 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28052 wxPyEndAllowThreads(__tstate);
28053 if (PyErr_Occurred()) SWIG_fail;
28054 }
28055 {
28056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28057 }
28058 return resultobj;
28059 fail:
28060 return NULL;
28061 }
28062
28063
28064 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28065 PyObject *resultobj = 0;
28066 wxDateTime *arg1 = (wxDateTime *) 0 ;
28067 wxDateTime *arg2 = (wxDateTime *) 0 ;
28068 bool result;
28069 void *argp1 = 0 ;
28070 int res1 = 0 ;
28071 void *argp2 = 0 ;
28072 int res2 = 0 ;
28073 PyObject * obj0 = 0 ;
28074 PyObject * obj1 = 0 ;
28075 char * kwnames[] = {
28076 (char *) "self",(char *) "other", NULL
28077 };
28078
28079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28081 if (!SWIG_IsOK(res1)) {
28082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28083 }
28084 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28086 if (!SWIG_IsOK(res2)) {
28087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28088 }
28089 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 {
28097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28098 }
28099 return resultobj;
28100 fail:
28101 return NULL;
28102 }
28103
28104
28105 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28106 PyObject *resultobj = 0;
28107 wxDateTime *arg1 = (wxDateTime *) 0 ;
28108 wxDateTime *arg2 = (wxDateTime *) 0 ;
28109 bool result;
28110 void *argp1 = 0 ;
28111 int res1 = 0 ;
28112 void *argp2 = 0 ;
28113 int res2 = 0 ;
28114 PyObject * obj0 = 0 ;
28115 PyObject * obj1 = 0 ;
28116 char * kwnames[] = {
28117 (char *) "self",(char *) "other", NULL
28118 };
28119
28120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28122 if (!SWIG_IsOK(res1)) {
28123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28124 }
28125 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28127 if (!SWIG_IsOK(res2)) {
28128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28129 }
28130 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28131 {
28132 PyThreadState* __tstate = wxPyBeginAllowThreads();
28133 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28134 wxPyEndAllowThreads(__tstate);
28135 if (PyErr_Occurred()) SWIG_fail;
28136 }
28137 {
28138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28139 }
28140 return resultobj;
28141 fail:
28142 return NULL;
28143 }
28144
28145
28146 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28147 PyObject *resultobj = 0;
28148 wxDateTime *arg1 = (wxDateTime *) 0 ;
28149 wxDateTime *arg2 = (wxDateTime *) 0 ;
28150 bool result;
28151 void *argp1 = 0 ;
28152 int res1 = 0 ;
28153 void *argp2 = 0 ;
28154 int res2 = 0 ;
28155 PyObject * obj0 = 0 ;
28156 PyObject * obj1 = 0 ;
28157 char * kwnames[] = {
28158 (char *) "self",(char *) "other", NULL
28159 };
28160
28161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28163 if (!SWIG_IsOK(res1)) {
28164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28165 }
28166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28168 if (!SWIG_IsOK(res2)) {
28169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28170 }
28171 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28172 {
28173 PyThreadState* __tstate = wxPyBeginAllowThreads();
28174 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 {
28179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28180 }
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28188 PyObject *resultobj = 0;
28189 wxDateTime *arg1 = (wxDateTime *) 0 ;
28190 wxString *arg2 = 0 ;
28191 int result;
28192 void *argp1 = 0 ;
28193 int res1 = 0 ;
28194 bool temp2 = false ;
28195 PyObject * obj0 = 0 ;
28196 PyObject * obj1 = 0 ;
28197 char * kwnames[] = {
28198 (char *) "self",(char *) "date", NULL
28199 };
28200
28201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28203 if (!SWIG_IsOK(res1)) {
28204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28205 }
28206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28207 {
28208 arg2 = wxString_in_helper(obj1);
28209 if (arg2 == NULL) SWIG_fail;
28210 temp2 = true;
28211 }
28212 {
28213 PyThreadState* __tstate = wxPyBeginAllowThreads();
28214 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28215 wxPyEndAllowThreads(__tstate);
28216 if (PyErr_Occurred()) SWIG_fail;
28217 }
28218 resultobj = SWIG_From_int(static_cast< int >(result));
28219 {
28220 if (temp2)
28221 delete arg2;
28222 }
28223 return resultobj;
28224 fail:
28225 {
28226 if (temp2)
28227 delete arg2;
28228 }
28229 return NULL;
28230 }
28231
28232
28233 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28234 PyObject *resultobj = 0;
28235 wxDateTime *arg1 = (wxDateTime *) 0 ;
28236 wxString *arg2 = 0 ;
28237 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28238 wxString *arg3 = (wxString *) &arg3_defvalue ;
28239 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28240 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28241 int result;
28242 void *argp1 = 0 ;
28243 int res1 = 0 ;
28244 bool temp2 = false ;
28245 bool temp3 = false ;
28246 void *argp4 = 0 ;
28247 int res4 = 0 ;
28248 PyObject * obj0 = 0 ;
28249 PyObject * obj1 = 0 ;
28250 PyObject * obj2 = 0 ;
28251 PyObject * obj3 = 0 ;
28252 char * kwnames[] = {
28253 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28254 };
28255
28256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28258 if (!SWIG_IsOK(res1)) {
28259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28260 }
28261 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28262 {
28263 arg2 = wxString_in_helper(obj1);
28264 if (arg2 == NULL) SWIG_fail;
28265 temp2 = true;
28266 }
28267 if (obj2) {
28268 {
28269 arg3 = wxString_in_helper(obj2);
28270 if (arg3 == NULL) SWIG_fail;
28271 temp3 = true;
28272 }
28273 }
28274 if (obj3) {
28275 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28276 if (!SWIG_IsOK(res4)) {
28277 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28278 }
28279 if (!argp4) {
28280 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28281 }
28282 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28283 }
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 resultobj = SWIG_From_int(static_cast< int >(result));
28291 {
28292 if (temp2)
28293 delete arg2;
28294 }
28295 {
28296 if (temp3)
28297 delete arg3;
28298 }
28299 return resultobj;
28300 fail:
28301 {
28302 if (temp2)
28303 delete arg2;
28304 }
28305 {
28306 if (temp3)
28307 delete arg3;
28308 }
28309 return NULL;
28310 }
28311
28312
28313 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28314 PyObject *resultobj = 0;
28315 wxDateTime *arg1 = (wxDateTime *) 0 ;
28316 wxString *arg2 = 0 ;
28317 int result;
28318 void *argp1 = 0 ;
28319 int res1 = 0 ;
28320 bool temp2 = false ;
28321 PyObject * obj0 = 0 ;
28322 PyObject * obj1 = 0 ;
28323 char * kwnames[] = {
28324 (char *) "self",(char *) "datetime", NULL
28325 };
28326
28327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28329 if (!SWIG_IsOK(res1)) {
28330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28331 }
28332 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28333 {
28334 arg2 = wxString_in_helper(obj1);
28335 if (arg2 == NULL) SWIG_fail;
28336 temp2 = true;
28337 }
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28341 wxPyEndAllowThreads(__tstate);
28342 if (PyErr_Occurred()) SWIG_fail;
28343 }
28344 resultobj = SWIG_From_int(static_cast< int >(result));
28345 {
28346 if (temp2)
28347 delete arg2;
28348 }
28349 return resultobj;
28350 fail:
28351 {
28352 if (temp2)
28353 delete arg2;
28354 }
28355 return NULL;
28356 }
28357
28358
28359 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj = 0;
28361 wxDateTime *arg1 = (wxDateTime *) 0 ;
28362 wxString *arg2 = 0 ;
28363 int result;
28364 void *argp1 = 0 ;
28365 int res1 = 0 ;
28366 bool temp2 = false ;
28367 PyObject * obj0 = 0 ;
28368 PyObject * obj1 = 0 ;
28369 char * kwnames[] = {
28370 (char *) "self",(char *) "date", NULL
28371 };
28372
28373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28375 if (!SWIG_IsOK(res1)) {
28376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28377 }
28378 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28379 {
28380 arg2 = wxString_in_helper(obj1);
28381 if (arg2 == NULL) SWIG_fail;
28382 temp2 = true;
28383 }
28384 {
28385 PyThreadState* __tstate = wxPyBeginAllowThreads();
28386 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28387 wxPyEndAllowThreads(__tstate);
28388 if (PyErr_Occurred()) SWIG_fail;
28389 }
28390 resultobj = SWIG_From_int(static_cast< int >(result));
28391 {
28392 if (temp2)
28393 delete arg2;
28394 }
28395 return resultobj;
28396 fail:
28397 {
28398 if (temp2)
28399 delete arg2;
28400 }
28401 return NULL;
28402 }
28403
28404
28405 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28406 PyObject *resultobj = 0;
28407 wxDateTime *arg1 = (wxDateTime *) 0 ;
28408 wxString *arg2 = 0 ;
28409 int result;
28410 void *argp1 = 0 ;
28411 int res1 = 0 ;
28412 bool temp2 = false ;
28413 PyObject * obj0 = 0 ;
28414 PyObject * obj1 = 0 ;
28415 char * kwnames[] = {
28416 (char *) "self",(char *) "time", NULL
28417 };
28418
28419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28421 if (!SWIG_IsOK(res1)) {
28422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28423 }
28424 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28425 {
28426 arg2 = wxString_in_helper(obj1);
28427 if (arg2 == NULL) SWIG_fail;
28428 temp2 = true;
28429 }
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28433 wxPyEndAllowThreads(__tstate);
28434 if (PyErr_Occurred()) SWIG_fail;
28435 }
28436 resultobj = SWIG_From_int(static_cast< int >(result));
28437 {
28438 if (temp2)
28439 delete arg2;
28440 }
28441 return resultobj;
28442 fail:
28443 {
28444 if (temp2)
28445 delete arg2;
28446 }
28447 return NULL;
28448 }
28449
28450
28451 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28452 PyObject *resultobj = 0;
28453 wxDateTime *arg1 = (wxDateTime *) 0 ;
28454 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28455 wxString *arg2 = (wxString *) &arg2_defvalue ;
28456 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28457 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28458 wxString result;
28459 void *argp1 = 0 ;
28460 int res1 = 0 ;
28461 bool temp2 = false ;
28462 bool temp3 = false ;
28463 PyObject * obj0 = 0 ;
28464 PyObject * obj1 = 0 ;
28465 PyObject * obj2 = 0 ;
28466 char * kwnames[] = {
28467 (char *) "self",(char *) "format",(char *) "tz", NULL
28468 };
28469
28470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28472 if (!SWIG_IsOK(res1)) {
28473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28474 }
28475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28476 if (obj1) {
28477 {
28478 arg2 = wxString_in_helper(obj1);
28479 if (arg2 == NULL) SWIG_fail;
28480 temp2 = true;
28481 }
28482 }
28483 if (obj2) {
28484 {
28485 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28486 temp3 = true;
28487 }
28488 }
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 #if wxUSE_UNICODE
28497 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28498 #else
28499 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28500 #endif
28501 }
28502 {
28503 if (temp2)
28504 delete arg2;
28505 }
28506 {
28507 if (temp3) delete arg3;
28508 }
28509 return resultobj;
28510 fail:
28511 {
28512 if (temp2)
28513 delete arg2;
28514 }
28515 {
28516 if (temp3) delete arg3;
28517 }
28518 return NULL;
28519 }
28520
28521
28522 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28523 PyObject *resultobj = 0;
28524 wxDateTime *arg1 = (wxDateTime *) 0 ;
28525 wxString result;
28526 void *argp1 = 0 ;
28527 int res1 = 0 ;
28528 PyObject *swig_obj[1] ;
28529
28530 if (!args) SWIG_fail;
28531 swig_obj[0] = args;
28532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28533 if (!SWIG_IsOK(res1)) {
28534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28535 }
28536 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = ((wxDateTime const *)arg1)->FormatDate();
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 {
28544 #if wxUSE_UNICODE
28545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28546 #else
28547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28548 #endif
28549 }
28550 return resultobj;
28551 fail:
28552 return NULL;
28553 }
28554
28555
28556 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28557 PyObject *resultobj = 0;
28558 wxDateTime *arg1 = (wxDateTime *) 0 ;
28559 wxString result;
28560 void *argp1 = 0 ;
28561 int res1 = 0 ;
28562 PyObject *swig_obj[1] ;
28563
28564 if (!args) SWIG_fail;
28565 swig_obj[0] = args;
28566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28567 if (!SWIG_IsOK(res1)) {
28568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28569 }
28570 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 result = ((wxDateTime const *)arg1)->FormatTime();
28574 wxPyEndAllowThreads(__tstate);
28575 if (PyErr_Occurred()) SWIG_fail;
28576 }
28577 {
28578 #if wxUSE_UNICODE
28579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28580 #else
28581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28582 #endif
28583 }
28584 return resultobj;
28585 fail:
28586 return NULL;
28587 }
28588
28589
28590 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28591 PyObject *resultobj = 0;
28592 wxDateTime *arg1 = (wxDateTime *) 0 ;
28593 wxString result;
28594 void *argp1 = 0 ;
28595 int res1 = 0 ;
28596 PyObject *swig_obj[1] ;
28597
28598 if (!args) SWIG_fail;
28599 swig_obj[0] = args;
28600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28601 if (!SWIG_IsOK(res1)) {
28602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28603 }
28604 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 result = ((wxDateTime const *)arg1)->FormatISODate();
28608 wxPyEndAllowThreads(__tstate);
28609 if (PyErr_Occurred()) SWIG_fail;
28610 }
28611 {
28612 #if wxUSE_UNICODE
28613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28614 #else
28615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28616 #endif
28617 }
28618 return resultobj;
28619 fail:
28620 return NULL;
28621 }
28622
28623
28624 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28625 PyObject *resultobj = 0;
28626 wxDateTime *arg1 = (wxDateTime *) 0 ;
28627 wxString result;
28628 void *argp1 = 0 ;
28629 int res1 = 0 ;
28630 PyObject *swig_obj[1] ;
28631
28632 if (!args) SWIG_fail;
28633 swig_obj[0] = args;
28634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28635 if (!SWIG_IsOK(res1)) {
28636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28637 }
28638 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 result = ((wxDateTime const *)arg1)->FormatISOTime();
28642 wxPyEndAllowThreads(__tstate);
28643 if (PyErr_Occurred()) SWIG_fail;
28644 }
28645 {
28646 #if wxUSE_UNICODE
28647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28648 #else
28649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28650 #endif
28651 }
28652 return resultobj;
28653 fail:
28654 return NULL;
28655 }
28656
28657
28658 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28659 PyObject *obj;
28660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28661 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28662 return SWIG_Py_Void();
28663 }
28664
28665 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28666 return SWIG_Python_InitShadowInstance(args);
28667 }
28668
28669 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28670 PyObject *resultobj = 0;
28671 long arg1 ;
28672 wxTimeSpan result;
28673 long val1 ;
28674 int ecode1 = 0 ;
28675 PyObject * obj0 = 0 ;
28676 char * kwnames[] = {
28677 (char *) "ms", NULL
28678 };
28679
28680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28681 ecode1 = SWIG_AsVal_long(obj0, &val1);
28682 if (!SWIG_IsOK(ecode1)) {
28683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28684 }
28685 arg1 = static_cast< long >(val1);
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 result = wxTimeSpan::Milliseconds(arg1);
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *resultobj = 0;
28701 wxTimeSpan result;
28702
28703 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28704 {
28705 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 result = wxTimeSpan::Millisecond();
28707 wxPyEndAllowThreads(__tstate);
28708 if (PyErr_Occurred()) SWIG_fail;
28709 }
28710 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28711 return resultobj;
28712 fail:
28713 return NULL;
28714 }
28715
28716
28717 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28718 PyObject *resultobj = 0;
28719 long arg1 ;
28720 wxTimeSpan result;
28721 long val1 ;
28722 int ecode1 = 0 ;
28723 PyObject * obj0 = 0 ;
28724 char * kwnames[] = {
28725 (char *) "sec", NULL
28726 };
28727
28728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28729 ecode1 = SWIG_AsVal_long(obj0, &val1);
28730 if (!SWIG_IsOK(ecode1)) {
28731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28732 }
28733 arg1 = static_cast< long >(val1);
28734 {
28735 PyThreadState* __tstate = wxPyBeginAllowThreads();
28736 result = wxTimeSpan::Seconds(arg1);
28737 wxPyEndAllowThreads(__tstate);
28738 if (PyErr_Occurred()) SWIG_fail;
28739 }
28740 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28741 return resultobj;
28742 fail:
28743 return NULL;
28744 }
28745
28746
28747 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28748 PyObject *resultobj = 0;
28749 wxTimeSpan result;
28750
28751 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 result = wxTimeSpan::Second();
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28766 PyObject *resultobj = 0;
28767 long arg1 ;
28768 wxTimeSpan result;
28769 long val1 ;
28770 int ecode1 = 0 ;
28771 PyObject * obj0 = 0 ;
28772 char * kwnames[] = {
28773 (char *) "min", NULL
28774 };
28775
28776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28777 ecode1 = SWIG_AsVal_long(obj0, &val1);
28778 if (!SWIG_IsOK(ecode1)) {
28779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28780 }
28781 arg1 = static_cast< long >(val1);
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = wxTimeSpan::Minutes(arg1);
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28796 PyObject *resultobj = 0;
28797 wxTimeSpan result;
28798
28799 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28800 {
28801 PyThreadState* __tstate = wxPyBeginAllowThreads();
28802 result = wxTimeSpan::Minute();
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28814 PyObject *resultobj = 0;
28815 long arg1 ;
28816 wxTimeSpan result;
28817 long val1 ;
28818 int ecode1 = 0 ;
28819 PyObject * obj0 = 0 ;
28820 char * kwnames[] = {
28821 (char *) "hours", NULL
28822 };
28823
28824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28825 ecode1 = SWIG_AsVal_long(obj0, &val1);
28826 if (!SWIG_IsOK(ecode1)) {
28827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28828 }
28829 arg1 = static_cast< long >(val1);
28830 {
28831 PyThreadState* __tstate = wxPyBeginAllowThreads();
28832 result = wxTimeSpan::Hours(arg1);
28833 wxPyEndAllowThreads(__tstate);
28834 if (PyErr_Occurred()) SWIG_fail;
28835 }
28836 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28844 PyObject *resultobj = 0;
28845 wxTimeSpan result;
28846
28847 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28848 {
28849 PyThreadState* __tstate = wxPyBeginAllowThreads();
28850 result = wxTimeSpan::Hour();
28851 wxPyEndAllowThreads(__tstate);
28852 if (PyErr_Occurred()) SWIG_fail;
28853 }
28854 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28862 PyObject *resultobj = 0;
28863 long arg1 ;
28864 wxTimeSpan result;
28865 long val1 ;
28866 int ecode1 = 0 ;
28867 PyObject * obj0 = 0 ;
28868 char * kwnames[] = {
28869 (char *) "days", NULL
28870 };
28871
28872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28873 ecode1 = SWIG_AsVal_long(obj0, &val1);
28874 if (!SWIG_IsOK(ecode1)) {
28875 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28876 }
28877 arg1 = static_cast< long >(val1);
28878 {
28879 PyThreadState* __tstate = wxPyBeginAllowThreads();
28880 result = wxTimeSpan::Days(arg1);
28881 wxPyEndAllowThreads(__tstate);
28882 if (PyErr_Occurred()) SWIG_fail;
28883 }
28884 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28892 PyObject *resultobj = 0;
28893 wxTimeSpan result;
28894
28895 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28896 {
28897 PyThreadState* __tstate = wxPyBeginAllowThreads();
28898 result = wxTimeSpan::Day();
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj = 0;
28911 long arg1 ;
28912 wxTimeSpan result;
28913 long val1 ;
28914 int ecode1 = 0 ;
28915 PyObject * obj0 = 0 ;
28916 char * kwnames[] = {
28917 (char *) "days", NULL
28918 };
28919
28920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28921 ecode1 = SWIG_AsVal_long(obj0, &val1);
28922 if (!SWIG_IsOK(ecode1)) {
28923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28924 }
28925 arg1 = static_cast< long >(val1);
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = wxTimeSpan::Weeks(arg1);
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 wxTimeSpan result;
28942
28943 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28944 {
28945 PyThreadState* __tstate = wxPyBeginAllowThreads();
28946 result = wxTimeSpan::Week();
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28958 PyObject *resultobj = 0;
28959 long arg1 = (long) 0 ;
28960 long arg2 = (long) 0 ;
28961 long arg3 = (long) 0 ;
28962 long arg4 = (long) 0 ;
28963 wxTimeSpan *result = 0 ;
28964 long val1 ;
28965 int ecode1 = 0 ;
28966 long val2 ;
28967 int ecode2 = 0 ;
28968 long val3 ;
28969 int ecode3 = 0 ;
28970 long val4 ;
28971 int ecode4 = 0 ;
28972 PyObject * obj0 = 0 ;
28973 PyObject * obj1 = 0 ;
28974 PyObject * obj2 = 0 ;
28975 PyObject * obj3 = 0 ;
28976 char * kwnames[] = {
28977 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28978 };
28979
28980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28981 if (obj0) {
28982 ecode1 = SWIG_AsVal_long(obj0, &val1);
28983 if (!SWIG_IsOK(ecode1)) {
28984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28985 }
28986 arg1 = static_cast< long >(val1);
28987 }
28988 if (obj1) {
28989 ecode2 = SWIG_AsVal_long(obj1, &val2);
28990 if (!SWIG_IsOK(ecode2)) {
28991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28992 }
28993 arg2 = static_cast< long >(val2);
28994 }
28995 if (obj2) {
28996 ecode3 = SWIG_AsVal_long(obj2, &val3);
28997 if (!SWIG_IsOK(ecode3)) {
28998 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28999 }
29000 arg3 = static_cast< long >(val3);
29001 }
29002 if (obj3) {
29003 ecode4 = SWIG_AsVal_long(obj3, &val4);
29004 if (!SWIG_IsOK(ecode4)) {
29005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
29006 }
29007 arg4 = static_cast< long >(val4);
29008 }
29009 {
29010 PyThreadState* __tstate = wxPyBeginAllowThreads();
29011 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
29012 wxPyEndAllowThreads(__tstate);
29013 if (PyErr_Occurred()) SWIG_fail;
29014 }
29015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
29016 return resultobj;
29017 fail:
29018 return NULL;
29019 }
29020
29021
29022 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29023 PyObject *resultobj = 0;
29024 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29025 void *argp1 = 0 ;
29026 int res1 = 0 ;
29027 PyObject *swig_obj[1] ;
29028
29029 if (!args) SWIG_fail;
29030 swig_obj[0] = args;
29031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29032 if (!SWIG_IsOK(res1)) {
29033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29034 }
29035 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 delete arg1;
29039
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 resultobj = SWIG_Py_Void();
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29051 PyObject *resultobj = 0;
29052 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29053 wxTimeSpan *arg2 = 0 ;
29054 wxTimeSpan *result = 0 ;
29055 void *argp1 = 0 ;
29056 int res1 = 0 ;
29057 void *argp2 = 0 ;
29058 int res2 = 0 ;
29059 PyObject * obj0 = 0 ;
29060 PyObject * obj1 = 0 ;
29061 char * kwnames[] = {
29062 (char *) "self",(char *) "diff", NULL
29063 };
29064
29065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29067 if (!SWIG_IsOK(res1)) {
29068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29069 }
29070 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29071 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29072 if (!SWIG_IsOK(res2)) {
29073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29074 }
29075 if (!argp2) {
29076 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29077 }
29078 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 {
29082 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29083 result = (wxTimeSpan *) &_result_ref;
29084 }
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29089 return resultobj;
29090 fail:
29091 return NULL;
29092 }
29093
29094
29095 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29096 PyObject *resultobj = 0;
29097 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29098 wxTimeSpan *arg2 = 0 ;
29099 wxTimeSpan *result = 0 ;
29100 void *argp1 = 0 ;
29101 int res1 = 0 ;
29102 void *argp2 = 0 ;
29103 int res2 = 0 ;
29104 PyObject * obj0 = 0 ;
29105 PyObject * obj1 = 0 ;
29106 char * kwnames[] = {
29107 (char *) "self",(char *) "diff", NULL
29108 };
29109
29110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29112 if (!SWIG_IsOK(res1)) {
29113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29114 }
29115 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29117 if (!SWIG_IsOK(res2)) {
29118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29119 }
29120 if (!argp2) {
29121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29122 }
29123 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29124 {
29125 PyThreadState* __tstate = wxPyBeginAllowThreads();
29126 {
29127 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29128 result = (wxTimeSpan *) &_result_ref;
29129 }
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29134 return resultobj;
29135 fail:
29136 return NULL;
29137 }
29138
29139
29140 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29141 PyObject *resultobj = 0;
29142 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29143 int arg2 ;
29144 wxTimeSpan *result = 0 ;
29145 void *argp1 = 0 ;
29146 int res1 = 0 ;
29147 int val2 ;
29148 int ecode2 = 0 ;
29149 PyObject * obj0 = 0 ;
29150 PyObject * obj1 = 0 ;
29151 char * kwnames[] = {
29152 (char *) "self",(char *) "n", NULL
29153 };
29154
29155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29157 if (!SWIG_IsOK(res1)) {
29158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29159 }
29160 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29161 ecode2 = SWIG_AsVal_int(obj1, &val2);
29162 if (!SWIG_IsOK(ecode2)) {
29163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29164 }
29165 arg2 = static_cast< int >(val2);
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 {
29169 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29170 result = (wxTimeSpan *) &_result_ref;
29171 }
29172 wxPyEndAllowThreads(__tstate);
29173 if (PyErr_Occurred()) SWIG_fail;
29174 }
29175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29176 return resultobj;
29177 fail:
29178 return NULL;
29179 }
29180
29181
29182 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29183 PyObject *resultobj = 0;
29184 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29185 wxTimeSpan *result = 0 ;
29186 void *argp1 = 0 ;
29187 int res1 = 0 ;
29188 PyObject *swig_obj[1] ;
29189
29190 if (!args) SWIG_fail;
29191 swig_obj[0] = args;
29192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29193 if (!SWIG_IsOK(res1)) {
29194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29195 }
29196 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29197 {
29198 PyThreadState* __tstate = wxPyBeginAllowThreads();
29199 {
29200 wxTimeSpan &_result_ref = (arg1)->Neg();
29201 result = (wxTimeSpan *) &_result_ref;
29202 }
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29207 return resultobj;
29208 fail:
29209 return NULL;
29210 }
29211
29212
29213 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29214 PyObject *resultobj = 0;
29215 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29216 wxTimeSpan result;
29217 void *argp1 = 0 ;
29218 int res1 = 0 ;
29219 PyObject *swig_obj[1] ;
29220
29221 if (!args) SWIG_fail;
29222 swig_obj[0] = args;
29223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29224 if (!SWIG_IsOK(res1)) {
29225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29226 }
29227 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 result = ((wxTimeSpan const *)arg1)->Abs();
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29242 PyObject *resultobj = 0;
29243 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29244 wxTimeSpan *arg2 = 0 ;
29245 wxTimeSpan *result = 0 ;
29246 void *argp1 = 0 ;
29247 int res1 = 0 ;
29248 void *argp2 = 0 ;
29249 int res2 = 0 ;
29250 PyObject * obj0 = 0 ;
29251 PyObject * obj1 = 0 ;
29252 char * kwnames[] = {
29253 (char *) "self",(char *) "diff", NULL
29254 };
29255
29256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29258 if (!SWIG_IsOK(res1)) {
29259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29260 }
29261 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29262 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29263 if (!SWIG_IsOK(res2)) {
29264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29265 }
29266 if (!argp2) {
29267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29268 }
29269 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29270 {
29271 PyThreadState* __tstate = wxPyBeginAllowThreads();
29272 {
29273 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29274 result = (wxTimeSpan *) &_result_ref;
29275 }
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj = 0;
29288 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29289 wxTimeSpan *arg2 = 0 ;
29290 wxTimeSpan *result = 0 ;
29291 void *argp1 = 0 ;
29292 int res1 = 0 ;
29293 void *argp2 = 0 ;
29294 int res2 = 0 ;
29295 PyObject * obj0 = 0 ;
29296 PyObject * obj1 = 0 ;
29297 char * kwnames[] = {
29298 (char *) "self",(char *) "diff", NULL
29299 };
29300
29301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29303 if (!SWIG_IsOK(res1)) {
29304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29305 }
29306 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29307 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29308 if (!SWIG_IsOK(res2)) {
29309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29310 }
29311 if (!argp2) {
29312 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29313 }
29314 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29315 {
29316 PyThreadState* __tstate = wxPyBeginAllowThreads();
29317 {
29318 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29319 result = (wxTimeSpan *) &_result_ref;
29320 }
29321 wxPyEndAllowThreads(__tstate);
29322 if (PyErr_Occurred()) SWIG_fail;
29323 }
29324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29332 PyObject *resultobj = 0;
29333 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29334 int arg2 ;
29335 wxTimeSpan *result = 0 ;
29336 void *argp1 = 0 ;
29337 int res1 = 0 ;
29338 int val2 ;
29339 int ecode2 = 0 ;
29340 PyObject * obj0 = 0 ;
29341 PyObject * obj1 = 0 ;
29342 char * kwnames[] = {
29343 (char *) "self",(char *) "n", NULL
29344 };
29345
29346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29348 if (!SWIG_IsOK(res1)) {
29349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29350 }
29351 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29352 ecode2 = SWIG_AsVal_int(obj1, &val2);
29353 if (!SWIG_IsOK(ecode2)) {
29354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29355 }
29356 arg2 = static_cast< int >(val2);
29357 {
29358 PyThreadState* __tstate = wxPyBeginAllowThreads();
29359 {
29360 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29361 result = (wxTimeSpan *) &_result_ref;
29362 }
29363 wxPyEndAllowThreads(__tstate);
29364 if (PyErr_Occurred()) SWIG_fail;
29365 }
29366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29367 return resultobj;
29368 fail:
29369 return NULL;
29370 }
29371
29372
29373 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29374 PyObject *resultobj = 0;
29375 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29376 wxTimeSpan *result = 0 ;
29377 void *argp1 = 0 ;
29378 int res1 = 0 ;
29379 PyObject *swig_obj[1] ;
29380
29381 if (!args) SWIG_fail;
29382 swig_obj[0] = args;
29383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29384 if (!SWIG_IsOK(res1)) {
29385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29386 }
29387 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29388 {
29389 PyThreadState* __tstate = wxPyBeginAllowThreads();
29390 {
29391 wxTimeSpan &_result_ref = (arg1)->operator -();
29392 result = (wxTimeSpan *) &_result_ref;
29393 }
29394 wxPyEndAllowThreads(__tstate);
29395 if (PyErr_Occurred()) SWIG_fail;
29396 }
29397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29405 PyObject *resultobj = 0;
29406 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29407 wxTimeSpan *arg2 = 0 ;
29408 wxTimeSpan result;
29409 void *argp1 = 0 ;
29410 int res1 = 0 ;
29411 void *argp2 = 0 ;
29412 int res2 = 0 ;
29413 PyObject * obj0 = 0 ;
29414 PyObject * obj1 = 0 ;
29415 char * kwnames[] = {
29416 (char *) "self",(char *) "other", NULL
29417 };
29418
29419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29421 if (!SWIG_IsOK(res1)) {
29422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29423 }
29424 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29425 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29426 if (!SWIG_IsOK(res2)) {
29427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29428 }
29429 if (!argp2) {
29430 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29431 }
29432 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29433 {
29434 PyThreadState* __tstate = wxPyBeginAllowThreads();
29435 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29436 wxPyEndAllowThreads(__tstate);
29437 if (PyErr_Occurred()) SWIG_fail;
29438 }
29439 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = 0;
29448 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29449 wxTimeSpan *arg2 = 0 ;
29450 wxTimeSpan result;
29451 void *argp1 = 0 ;
29452 int res1 = 0 ;
29453 void *argp2 = 0 ;
29454 int res2 = 0 ;
29455 PyObject * obj0 = 0 ;
29456 PyObject * obj1 = 0 ;
29457 char * kwnames[] = {
29458 (char *) "self",(char *) "other", NULL
29459 };
29460
29461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29463 if (!SWIG_IsOK(res1)) {
29464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29465 }
29466 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29468 if (!SWIG_IsOK(res2)) {
29469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29470 }
29471 if (!argp2) {
29472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29473 }
29474 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29475 {
29476 PyThreadState* __tstate = wxPyBeginAllowThreads();
29477 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29478 wxPyEndAllowThreads(__tstate);
29479 if (PyErr_Occurred()) SWIG_fail;
29480 }
29481 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29482 return resultobj;
29483 fail:
29484 return NULL;
29485 }
29486
29487
29488 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29489 PyObject *resultobj = 0;
29490 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29491 int arg2 ;
29492 wxTimeSpan result;
29493 void *argp1 = 0 ;
29494 int res1 = 0 ;
29495 int val2 ;
29496 int ecode2 = 0 ;
29497 PyObject * obj0 = 0 ;
29498 PyObject * obj1 = 0 ;
29499 char * kwnames[] = {
29500 (char *) "self",(char *) "n", NULL
29501 };
29502
29503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29505 if (!SWIG_IsOK(res1)) {
29506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29507 }
29508 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29509 ecode2 = SWIG_AsVal_int(obj1, &val2);
29510 if (!SWIG_IsOK(ecode2)) {
29511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29512 }
29513 arg2 = static_cast< int >(val2);
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = wxTimeSpan___mul__(arg1,arg2);
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29521 return resultobj;
29522 fail:
29523 return NULL;
29524 }
29525
29526
29527 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29528 PyObject *resultobj = 0;
29529 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29530 int arg2 ;
29531 wxTimeSpan result;
29532 void *argp1 = 0 ;
29533 int res1 = 0 ;
29534 int val2 ;
29535 int ecode2 = 0 ;
29536 PyObject * obj0 = 0 ;
29537 PyObject * obj1 = 0 ;
29538 char * kwnames[] = {
29539 (char *) "self",(char *) "n", NULL
29540 };
29541
29542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29544 if (!SWIG_IsOK(res1)) {
29545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29546 }
29547 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29548 ecode2 = SWIG_AsVal_int(obj1, &val2);
29549 if (!SWIG_IsOK(ecode2)) {
29550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29551 }
29552 arg2 = static_cast< int >(val2);
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = wxTimeSpan___rmul__(arg1,arg2);
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29560 return resultobj;
29561 fail:
29562 return NULL;
29563 }
29564
29565
29566 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29567 PyObject *resultobj = 0;
29568 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29569 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29570 bool result;
29571 void *argp1 = 0 ;
29572 int res1 = 0 ;
29573 void *argp2 = 0 ;
29574 int res2 = 0 ;
29575 PyObject * obj0 = 0 ;
29576 PyObject * obj1 = 0 ;
29577 char * kwnames[] = {
29578 (char *) "self",(char *) "other", NULL
29579 };
29580
29581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29583 if (!SWIG_IsOK(res1)) {
29584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29585 }
29586 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29588 if (!SWIG_IsOK(res2)) {
29589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29590 }
29591 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 {
29599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29600 }
29601 return resultobj;
29602 fail:
29603 return NULL;
29604 }
29605
29606
29607 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29608 PyObject *resultobj = 0;
29609 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29610 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29611 bool result;
29612 void *argp1 = 0 ;
29613 int res1 = 0 ;
29614 void *argp2 = 0 ;
29615 int res2 = 0 ;
29616 PyObject * obj0 = 0 ;
29617 PyObject * obj1 = 0 ;
29618 char * kwnames[] = {
29619 (char *) "self",(char *) "other", NULL
29620 };
29621
29622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29624 if (!SWIG_IsOK(res1)) {
29625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29626 }
29627 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29629 if (!SWIG_IsOK(res2)) {
29630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29631 }
29632 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29633 {
29634 PyThreadState* __tstate = wxPyBeginAllowThreads();
29635 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29636 wxPyEndAllowThreads(__tstate);
29637 if (PyErr_Occurred()) SWIG_fail;
29638 }
29639 {
29640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29641 }
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29649 PyObject *resultobj = 0;
29650 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29651 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29652 bool result;
29653 void *argp1 = 0 ;
29654 int res1 = 0 ;
29655 void *argp2 = 0 ;
29656 int res2 = 0 ;
29657 PyObject * obj0 = 0 ;
29658 PyObject * obj1 = 0 ;
29659 char * kwnames[] = {
29660 (char *) "self",(char *) "other", NULL
29661 };
29662
29663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29665 if (!SWIG_IsOK(res1)) {
29666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29667 }
29668 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29669 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29670 if (!SWIG_IsOK(res2)) {
29671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29672 }
29673 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29674 {
29675 PyThreadState* __tstate = wxPyBeginAllowThreads();
29676 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 {
29681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29682 }
29683 return resultobj;
29684 fail:
29685 return NULL;
29686 }
29687
29688
29689 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29690 PyObject *resultobj = 0;
29691 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29692 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29693 bool result;
29694 void *argp1 = 0 ;
29695 int res1 = 0 ;
29696 void *argp2 = 0 ;
29697 int res2 = 0 ;
29698 PyObject * obj0 = 0 ;
29699 PyObject * obj1 = 0 ;
29700 char * kwnames[] = {
29701 (char *) "self",(char *) "other", NULL
29702 };
29703
29704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29706 if (!SWIG_IsOK(res1)) {
29707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29708 }
29709 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29711 if (!SWIG_IsOK(res2)) {
29712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29713 }
29714 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29718 wxPyEndAllowThreads(__tstate);
29719 if (PyErr_Occurred()) SWIG_fail;
29720 }
29721 {
29722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29723 }
29724 return resultobj;
29725 fail:
29726 return NULL;
29727 }
29728
29729
29730 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29731 PyObject *resultobj = 0;
29732 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29733 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29734 bool result;
29735 void *argp1 = 0 ;
29736 int res1 = 0 ;
29737 void *argp2 = 0 ;
29738 int res2 = 0 ;
29739 PyObject * obj0 = 0 ;
29740 PyObject * obj1 = 0 ;
29741 char * kwnames[] = {
29742 (char *) "self",(char *) "other", NULL
29743 };
29744
29745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29747 if (!SWIG_IsOK(res1)) {
29748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29749 }
29750 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29752 if (!SWIG_IsOK(res2)) {
29753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29754 }
29755 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29756 {
29757 PyThreadState* __tstate = wxPyBeginAllowThreads();
29758 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 {
29763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29764 }
29765 return resultobj;
29766 fail:
29767 return NULL;
29768 }
29769
29770
29771 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29772 PyObject *resultobj = 0;
29773 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29774 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29775 bool result;
29776 void *argp1 = 0 ;
29777 int res1 = 0 ;
29778 void *argp2 = 0 ;
29779 int res2 = 0 ;
29780 PyObject * obj0 = 0 ;
29781 PyObject * obj1 = 0 ;
29782 char * kwnames[] = {
29783 (char *) "self",(char *) "other", NULL
29784 };
29785
29786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29788 if (!SWIG_IsOK(res1)) {
29789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29790 }
29791 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29793 if (!SWIG_IsOK(res2)) {
29794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29795 }
29796 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 {
29804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29805 }
29806 return resultobj;
29807 fail:
29808 return NULL;
29809 }
29810
29811
29812 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29813 PyObject *resultobj = 0;
29814 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29815 bool result;
29816 void *argp1 = 0 ;
29817 int res1 = 0 ;
29818 PyObject *swig_obj[1] ;
29819
29820 if (!args) SWIG_fail;
29821 swig_obj[0] = args;
29822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29823 if (!SWIG_IsOK(res1)) {
29824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29825 }
29826 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29827 {
29828 PyThreadState* __tstate = wxPyBeginAllowThreads();
29829 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 {
29834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29835 }
29836 return resultobj;
29837 fail:
29838 return NULL;
29839 }
29840
29841
29842 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29843 PyObject *resultobj = 0;
29844 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29845 bool result;
29846 void *argp1 = 0 ;
29847 int res1 = 0 ;
29848 PyObject *swig_obj[1] ;
29849
29850 if (!args) SWIG_fail;
29851 swig_obj[0] = args;
29852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29853 if (!SWIG_IsOK(res1)) {
29854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29855 }
29856 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29857 {
29858 PyThreadState* __tstate = wxPyBeginAllowThreads();
29859 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29860 wxPyEndAllowThreads(__tstate);
29861 if (PyErr_Occurred()) SWIG_fail;
29862 }
29863 {
29864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29865 }
29866 return resultobj;
29867 fail:
29868 return NULL;
29869 }
29870
29871
29872 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29873 PyObject *resultobj = 0;
29874 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29875 bool result;
29876 void *argp1 = 0 ;
29877 int res1 = 0 ;
29878 PyObject *swig_obj[1] ;
29879
29880 if (!args) SWIG_fail;
29881 swig_obj[0] = args;
29882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29883 if (!SWIG_IsOK(res1)) {
29884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29885 }
29886 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29887 {
29888 PyThreadState* __tstate = wxPyBeginAllowThreads();
29889 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29890 wxPyEndAllowThreads(__tstate);
29891 if (PyErr_Occurred()) SWIG_fail;
29892 }
29893 {
29894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29895 }
29896 return resultobj;
29897 fail:
29898 return NULL;
29899 }
29900
29901
29902 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29903 PyObject *resultobj = 0;
29904 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29905 wxTimeSpan *arg2 = 0 ;
29906 bool result;
29907 void *argp1 = 0 ;
29908 int res1 = 0 ;
29909 void *argp2 = 0 ;
29910 int res2 = 0 ;
29911 PyObject * obj0 = 0 ;
29912 PyObject * obj1 = 0 ;
29913 char * kwnames[] = {
29914 (char *) "self",(char *) "ts", NULL
29915 };
29916
29917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29919 if (!SWIG_IsOK(res1)) {
29920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29921 }
29922 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29923 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29924 if (!SWIG_IsOK(res2)) {
29925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29926 }
29927 if (!argp2) {
29928 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29929 }
29930 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29931 {
29932 PyThreadState* __tstate = wxPyBeginAllowThreads();
29933 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29934 wxPyEndAllowThreads(__tstate);
29935 if (PyErr_Occurred()) SWIG_fail;
29936 }
29937 {
29938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29939 }
29940 return resultobj;
29941 fail:
29942 return NULL;
29943 }
29944
29945
29946 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29947 PyObject *resultobj = 0;
29948 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29949 wxTimeSpan *arg2 = 0 ;
29950 bool result;
29951 void *argp1 = 0 ;
29952 int res1 = 0 ;
29953 void *argp2 = 0 ;
29954 int res2 = 0 ;
29955 PyObject * obj0 = 0 ;
29956 PyObject * obj1 = 0 ;
29957 char * kwnames[] = {
29958 (char *) "self",(char *) "ts", NULL
29959 };
29960
29961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29963 if (!SWIG_IsOK(res1)) {
29964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29965 }
29966 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29967 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29968 if (!SWIG_IsOK(res2)) {
29969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29970 }
29971 if (!argp2) {
29972 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29973 }
29974 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29975 {
29976 PyThreadState* __tstate = wxPyBeginAllowThreads();
29977 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29978 wxPyEndAllowThreads(__tstate);
29979 if (PyErr_Occurred()) SWIG_fail;
29980 }
29981 {
29982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29983 }
29984 return resultobj;
29985 fail:
29986 return NULL;
29987 }
29988
29989
29990 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29991 PyObject *resultobj = 0;
29992 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29993 wxTimeSpan *arg2 = 0 ;
29994 bool result;
29995 void *argp1 = 0 ;
29996 int res1 = 0 ;
29997 void *argp2 = 0 ;
29998 int res2 = 0 ;
29999 PyObject * obj0 = 0 ;
30000 PyObject * obj1 = 0 ;
30001 char * kwnames[] = {
30002 (char *) "self",(char *) "t", NULL
30003 };
30004
30005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
30006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30007 if (!SWIG_IsOK(res1)) {
30008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30009 }
30010 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30011 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
30012 if (!SWIG_IsOK(res2)) {
30013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30014 }
30015 if (!argp2) {
30016 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30017 }
30018 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 {
30026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30027 }
30028 return resultobj;
30029 fail:
30030 return NULL;
30031 }
30032
30033
30034 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30035 PyObject *resultobj = 0;
30036 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30037 int result;
30038 void *argp1 = 0 ;
30039 int res1 = 0 ;
30040 PyObject *swig_obj[1] ;
30041
30042 if (!args) SWIG_fail;
30043 swig_obj[0] = args;
30044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30045 if (!SWIG_IsOK(res1)) {
30046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30047 }
30048 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30049 {
30050 PyThreadState* __tstate = wxPyBeginAllowThreads();
30051 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30052 wxPyEndAllowThreads(__tstate);
30053 if (PyErr_Occurred()) SWIG_fail;
30054 }
30055 resultobj = SWIG_From_int(static_cast< int >(result));
30056 return resultobj;
30057 fail:
30058 return NULL;
30059 }
30060
30061
30062 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30063 PyObject *resultobj = 0;
30064 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30065 int result;
30066 void *argp1 = 0 ;
30067 int res1 = 0 ;
30068 PyObject *swig_obj[1] ;
30069
30070 if (!args) SWIG_fail;
30071 swig_obj[0] = args;
30072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30073 if (!SWIG_IsOK(res1)) {
30074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30075 }
30076 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30077 {
30078 PyThreadState* __tstate = wxPyBeginAllowThreads();
30079 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30080 wxPyEndAllowThreads(__tstate);
30081 if (PyErr_Occurred()) SWIG_fail;
30082 }
30083 resultobj = SWIG_From_int(static_cast< int >(result));
30084 return resultobj;
30085 fail:
30086 return NULL;
30087 }
30088
30089
30090 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30091 PyObject *resultobj = 0;
30092 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30093 int result;
30094 void *argp1 = 0 ;
30095 int res1 = 0 ;
30096 PyObject *swig_obj[1] ;
30097
30098 if (!args) SWIG_fail;
30099 swig_obj[0] = args;
30100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30101 if (!SWIG_IsOK(res1)) {
30102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30103 }
30104 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30105 {
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30108 wxPyEndAllowThreads(__tstate);
30109 if (PyErr_Occurred()) SWIG_fail;
30110 }
30111 resultobj = SWIG_From_int(static_cast< int >(result));
30112 return resultobj;
30113 fail:
30114 return NULL;
30115 }
30116
30117
30118 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30119 PyObject *resultobj = 0;
30120 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30121 int result;
30122 void *argp1 = 0 ;
30123 int res1 = 0 ;
30124 PyObject *swig_obj[1] ;
30125
30126 if (!args) SWIG_fail;
30127 swig_obj[0] = args;
30128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30129 if (!SWIG_IsOK(res1)) {
30130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30131 }
30132 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30133 {
30134 PyThreadState* __tstate = wxPyBeginAllowThreads();
30135 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30136 wxPyEndAllowThreads(__tstate);
30137 if (PyErr_Occurred()) SWIG_fail;
30138 }
30139 resultobj = SWIG_From_int(static_cast< int >(result));
30140 return resultobj;
30141 fail:
30142 return NULL;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30147 PyObject *resultobj = 0;
30148 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30149 wxLongLong result;
30150 void *argp1 = 0 ;
30151 int res1 = 0 ;
30152 PyObject *swig_obj[1] ;
30153
30154 if (!args) SWIG_fail;
30155 swig_obj[0] = args;
30156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30157 if (!SWIG_IsOK(res1)) {
30158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30159 }
30160 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30161 {
30162 PyThreadState* __tstate = wxPyBeginAllowThreads();
30163 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30164 wxPyEndAllowThreads(__tstate);
30165 if (PyErr_Occurred()) SWIG_fail;
30166 }
30167 {
30168 PyObject *hi, *lo, *shifter, *shifted;
30169 hi = PyLong_FromLong( (&result)->GetHi() );
30170 lo = PyLong_FromLong( (&result)->GetLo() );
30171 shifter = PyLong_FromLong(32);
30172 shifted = PyNumber_Lshift(hi, shifter);
30173 resultobj = PyNumber_Or(shifted, lo);
30174 Py_DECREF(hi);
30175 Py_DECREF(lo);
30176 Py_DECREF(shifter);
30177 Py_DECREF(shifted);
30178 }
30179 return resultobj;
30180 fail:
30181 return NULL;
30182 }
30183
30184
30185 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30186 PyObject *resultobj = 0;
30187 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30188 wxLongLong result;
30189 void *argp1 = 0 ;
30190 int res1 = 0 ;
30191 PyObject *swig_obj[1] ;
30192
30193 if (!args) SWIG_fail;
30194 swig_obj[0] = args;
30195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30196 if (!SWIG_IsOK(res1)) {
30197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30198 }
30199 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30200 {
30201 PyThreadState* __tstate = wxPyBeginAllowThreads();
30202 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30203 wxPyEndAllowThreads(__tstate);
30204 if (PyErr_Occurred()) SWIG_fail;
30205 }
30206 {
30207 PyObject *hi, *lo, *shifter, *shifted;
30208 hi = PyLong_FromLong( (&result)->GetHi() );
30209 lo = PyLong_FromLong( (&result)->GetLo() );
30210 shifter = PyLong_FromLong(32);
30211 shifted = PyNumber_Lshift(hi, shifter);
30212 resultobj = PyNumber_Or(shifted, lo);
30213 Py_DECREF(hi);
30214 Py_DECREF(lo);
30215 Py_DECREF(shifter);
30216 Py_DECREF(shifted);
30217 }
30218 return resultobj;
30219 fail:
30220 return NULL;
30221 }
30222
30223
30224 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30225 PyObject *resultobj = 0;
30226 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30227 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30228 wxString *arg2 = (wxString *) &arg2_defvalue ;
30229 wxString result;
30230 void *argp1 = 0 ;
30231 int res1 = 0 ;
30232 bool temp2 = false ;
30233 PyObject * obj0 = 0 ;
30234 PyObject * obj1 = 0 ;
30235 char * kwnames[] = {
30236 (char *) "self",(char *) "format", NULL
30237 };
30238
30239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30241 if (!SWIG_IsOK(res1)) {
30242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30243 }
30244 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30245 if (obj1) {
30246 {
30247 arg2 = wxString_in_helper(obj1);
30248 if (arg2 == NULL) SWIG_fail;
30249 temp2 = true;
30250 }
30251 }
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30255 wxPyEndAllowThreads(__tstate);
30256 if (PyErr_Occurred()) SWIG_fail;
30257 }
30258 {
30259 #if wxUSE_UNICODE
30260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30261 #else
30262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30263 #endif
30264 }
30265 {
30266 if (temp2)
30267 delete arg2;
30268 }
30269 return resultobj;
30270 fail:
30271 {
30272 if (temp2)
30273 delete arg2;
30274 }
30275 return NULL;
30276 }
30277
30278
30279 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30280 PyObject *obj;
30281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30282 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30283 return SWIG_Py_Void();
30284 }
30285
30286 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30287 return SWIG_Python_InitShadowInstance(args);
30288 }
30289
30290 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30291 PyObject *resultobj = 0;
30292 int arg1 = (int) 0 ;
30293 int arg2 = (int) 0 ;
30294 int arg3 = (int) 0 ;
30295 int arg4 = (int) 0 ;
30296 wxDateSpan *result = 0 ;
30297 int val1 ;
30298 int ecode1 = 0 ;
30299 int val2 ;
30300 int ecode2 = 0 ;
30301 int val3 ;
30302 int ecode3 = 0 ;
30303 int val4 ;
30304 int ecode4 = 0 ;
30305 PyObject * obj0 = 0 ;
30306 PyObject * obj1 = 0 ;
30307 PyObject * obj2 = 0 ;
30308 PyObject * obj3 = 0 ;
30309 char * kwnames[] = {
30310 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30311 };
30312
30313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30314 if (obj0) {
30315 ecode1 = SWIG_AsVal_int(obj0, &val1);
30316 if (!SWIG_IsOK(ecode1)) {
30317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30318 }
30319 arg1 = static_cast< int >(val1);
30320 }
30321 if (obj1) {
30322 ecode2 = SWIG_AsVal_int(obj1, &val2);
30323 if (!SWIG_IsOK(ecode2)) {
30324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30325 }
30326 arg2 = static_cast< int >(val2);
30327 }
30328 if (obj2) {
30329 ecode3 = SWIG_AsVal_int(obj2, &val3);
30330 if (!SWIG_IsOK(ecode3)) {
30331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30332 }
30333 arg3 = static_cast< int >(val3);
30334 }
30335 if (obj3) {
30336 ecode4 = SWIG_AsVal_int(obj3, &val4);
30337 if (!SWIG_IsOK(ecode4)) {
30338 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30339 }
30340 arg4 = static_cast< int >(val4);
30341 }
30342 {
30343 PyThreadState* __tstate = wxPyBeginAllowThreads();
30344 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30345 wxPyEndAllowThreads(__tstate);
30346 if (PyErr_Occurred()) SWIG_fail;
30347 }
30348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30349 return resultobj;
30350 fail:
30351 return NULL;
30352 }
30353
30354
30355 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30356 PyObject *resultobj = 0;
30357 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30358 void *argp1 = 0 ;
30359 int res1 = 0 ;
30360 PyObject *swig_obj[1] ;
30361
30362 if (!args) SWIG_fail;
30363 swig_obj[0] = args;
30364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30365 if (!SWIG_IsOK(res1)) {
30366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30367 }
30368 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30369 {
30370 PyThreadState* __tstate = wxPyBeginAllowThreads();
30371 delete arg1;
30372
30373 wxPyEndAllowThreads(__tstate);
30374 if (PyErr_Occurred()) SWIG_fail;
30375 }
30376 resultobj = SWIG_Py_Void();
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30384 PyObject *resultobj = 0;
30385 int arg1 ;
30386 wxDateSpan result;
30387 int val1 ;
30388 int ecode1 = 0 ;
30389 PyObject * obj0 = 0 ;
30390 char * kwnames[] = {
30391 (char *) "days", NULL
30392 };
30393
30394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30395 ecode1 = SWIG_AsVal_int(obj0, &val1);
30396 if (!SWIG_IsOK(ecode1)) {
30397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30398 }
30399 arg1 = static_cast< int >(val1);
30400 {
30401 PyThreadState* __tstate = wxPyBeginAllowThreads();
30402 result = wxDateSpan::Days(arg1);
30403 wxPyEndAllowThreads(__tstate);
30404 if (PyErr_Occurred()) SWIG_fail;
30405 }
30406 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30414 PyObject *resultobj = 0;
30415 wxDateSpan result;
30416
30417 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30418 {
30419 PyThreadState* __tstate = wxPyBeginAllowThreads();
30420 result = wxDateSpan::Day();
30421 wxPyEndAllowThreads(__tstate);
30422 if (PyErr_Occurred()) SWIG_fail;
30423 }
30424 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30425 return resultobj;
30426 fail:
30427 return NULL;
30428 }
30429
30430
30431 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj = 0;
30433 int arg1 ;
30434 wxDateSpan result;
30435 int val1 ;
30436 int ecode1 = 0 ;
30437 PyObject * obj0 = 0 ;
30438 char * kwnames[] = {
30439 (char *) "weeks", NULL
30440 };
30441
30442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30443 ecode1 = SWIG_AsVal_int(obj0, &val1);
30444 if (!SWIG_IsOK(ecode1)) {
30445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30446 }
30447 arg1 = static_cast< int >(val1);
30448 {
30449 PyThreadState* __tstate = wxPyBeginAllowThreads();
30450 result = wxDateSpan::Weeks(arg1);
30451 wxPyEndAllowThreads(__tstate);
30452 if (PyErr_Occurred()) SWIG_fail;
30453 }
30454 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30462 PyObject *resultobj = 0;
30463 wxDateSpan result;
30464
30465 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30466 {
30467 PyThreadState* __tstate = wxPyBeginAllowThreads();
30468 result = wxDateSpan::Week();
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30480 PyObject *resultobj = 0;
30481 int arg1 ;
30482 wxDateSpan result;
30483 int val1 ;
30484 int ecode1 = 0 ;
30485 PyObject * obj0 = 0 ;
30486 char * kwnames[] = {
30487 (char *) "mon", NULL
30488 };
30489
30490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30491 ecode1 = SWIG_AsVal_int(obj0, &val1);
30492 if (!SWIG_IsOK(ecode1)) {
30493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30494 }
30495 arg1 = static_cast< int >(val1);
30496 {
30497 PyThreadState* __tstate = wxPyBeginAllowThreads();
30498 result = wxDateSpan::Months(arg1);
30499 wxPyEndAllowThreads(__tstate);
30500 if (PyErr_Occurred()) SWIG_fail;
30501 }
30502 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30503 return resultobj;
30504 fail:
30505 return NULL;
30506 }
30507
30508
30509 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30510 PyObject *resultobj = 0;
30511 wxDateSpan result;
30512
30513 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30514 {
30515 PyThreadState* __tstate = wxPyBeginAllowThreads();
30516 result = wxDateSpan::Month();
30517 wxPyEndAllowThreads(__tstate);
30518 if (PyErr_Occurred()) SWIG_fail;
30519 }
30520 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30521 return resultobj;
30522 fail:
30523 return NULL;
30524 }
30525
30526
30527 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30528 PyObject *resultobj = 0;
30529 int arg1 ;
30530 wxDateSpan result;
30531 int val1 ;
30532 int ecode1 = 0 ;
30533 PyObject * obj0 = 0 ;
30534 char * kwnames[] = {
30535 (char *) "years", NULL
30536 };
30537
30538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30539 ecode1 = SWIG_AsVal_int(obj0, &val1);
30540 if (!SWIG_IsOK(ecode1)) {
30541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30542 }
30543 arg1 = static_cast< int >(val1);
30544 {
30545 PyThreadState* __tstate = wxPyBeginAllowThreads();
30546 result = wxDateSpan::Years(arg1);
30547 wxPyEndAllowThreads(__tstate);
30548 if (PyErr_Occurred()) SWIG_fail;
30549 }
30550 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30551 return resultobj;
30552 fail:
30553 return NULL;
30554 }
30555
30556
30557 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30558 PyObject *resultobj = 0;
30559 wxDateSpan result;
30560
30561 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30562 {
30563 PyThreadState* __tstate = wxPyBeginAllowThreads();
30564 result = wxDateSpan::Year();
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30569 return resultobj;
30570 fail:
30571 return NULL;
30572 }
30573
30574
30575 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30576 PyObject *resultobj = 0;
30577 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30578 int arg2 ;
30579 wxDateSpan *result = 0 ;
30580 void *argp1 = 0 ;
30581 int res1 = 0 ;
30582 int val2 ;
30583 int ecode2 = 0 ;
30584 PyObject * obj0 = 0 ;
30585 PyObject * obj1 = 0 ;
30586 char * kwnames[] = {
30587 (char *) "self",(char *) "n", NULL
30588 };
30589
30590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30592 if (!SWIG_IsOK(res1)) {
30593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30594 }
30595 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30596 ecode2 = SWIG_AsVal_int(obj1, &val2);
30597 if (!SWIG_IsOK(ecode2)) {
30598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30599 }
30600 arg2 = static_cast< int >(val2);
30601 {
30602 PyThreadState* __tstate = wxPyBeginAllowThreads();
30603 {
30604 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30605 result = (wxDateSpan *) &_result_ref;
30606 }
30607 wxPyEndAllowThreads(__tstate);
30608 if (PyErr_Occurred()) SWIG_fail;
30609 }
30610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj = 0;
30619 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30620 int arg2 ;
30621 wxDateSpan *result = 0 ;
30622 void *argp1 = 0 ;
30623 int res1 = 0 ;
30624 int val2 ;
30625 int ecode2 = 0 ;
30626 PyObject * obj0 = 0 ;
30627 PyObject * obj1 = 0 ;
30628 char * kwnames[] = {
30629 (char *) "self",(char *) "n", NULL
30630 };
30631
30632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30634 if (!SWIG_IsOK(res1)) {
30635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30636 }
30637 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30638 ecode2 = SWIG_AsVal_int(obj1, &val2);
30639 if (!SWIG_IsOK(ecode2)) {
30640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30641 }
30642 arg2 = static_cast< int >(val2);
30643 {
30644 PyThreadState* __tstate = wxPyBeginAllowThreads();
30645 {
30646 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30647 result = (wxDateSpan *) &_result_ref;
30648 }
30649 wxPyEndAllowThreads(__tstate);
30650 if (PyErr_Occurred()) SWIG_fail;
30651 }
30652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30653 return resultobj;
30654 fail:
30655 return NULL;
30656 }
30657
30658
30659 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30660 PyObject *resultobj = 0;
30661 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30662 int arg2 ;
30663 wxDateSpan *result = 0 ;
30664 void *argp1 = 0 ;
30665 int res1 = 0 ;
30666 int val2 ;
30667 int ecode2 = 0 ;
30668 PyObject * obj0 = 0 ;
30669 PyObject * obj1 = 0 ;
30670 char * kwnames[] = {
30671 (char *) "self",(char *) "n", NULL
30672 };
30673
30674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30676 if (!SWIG_IsOK(res1)) {
30677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30678 }
30679 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30680 ecode2 = SWIG_AsVal_int(obj1, &val2);
30681 if (!SWIG_IsOK(ecode2)) {
30682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30683 }
30684 arg2 = static_cast< int >(val2);
30685 {
30686 PyThreadState* __tstate = wxPyBeginAllowThreads();
30687 {
30688 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30689 result = (wxDateSpan *) &_result_ref;
30690 }
30691 wxPyEndAllowThreads(__tstate);
30692 if (PyErr_Occurred()) SWIG_fail;
30693 }
30694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30695 return resultobj;
30696 fail:
30697 return NULL;
30698 }
30699
30700
30701 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30702 PyObject *resultobj = 0;
30703 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30704 int arg2 ;
30705 wxDateSpan *result = 0 ;
30706 void *argp1 = 0 ;
30707 int res1 = 0 ;
30708 int val2 ;
30709 int ecode2 = 0 ;
30710 PyObject * obj0 = 0 ;
30711 PyObject * obj1 = 0 ;
30712 char * kwnames[] = {
30713 (char *) "self",(char *) "n", NULL
30714 };
30715
30716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30718 if (!SWIG_IsOK(res1)) {
30719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30720 }
30721 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30722 ecode2 = SWIG_AsVal_int(obj1, &val2);
30723 if (!SWIG_IsOK(ecode2)) {
30724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30725 }
30726 arg2 = static_cast< int >(val2);
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 {
30730 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30731 result = (wxDateSpan *) &_result_ref;
30732 }
30733 wxPyEndAllowThreads(__tstate);
30734 if (PyErr_Occurred()) SWIG_fail;
30735 }
30736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30737 return resultobj;
30738 fail:
30739 return NULL;
30740 }
30741
30742
30743 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30744 PyObject *resultobj = 0;
30745 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30746 int result;
30747 void *argp1 = 0 ;
30748 int res1 = 0 ;
30749 PyObject *swig_obj[1] ;
30750
30751 if (!args) SWIG_fail;
30752 swig_obj[0] = args;
30753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30754 if (!SWIG_IsOK(res1)) {
30755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30756 }
30757 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 result = (int)((wxDateSpan const *)arg1)->GetYears();
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_From_int(static_cast< int >(result));
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30772 PyObject *resultobj = 0;
30773 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30774 int result;
30775 void *argp1 = 0 ;
30776 int res1 = 0 ;
30777 PyObject *swig_obj[1] ;
30778
30779 if (!args) SWIG_fail;
30780 swig_obj[0] = args;
30781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30782 if (!SWIG_IsOK(res1)) {
30783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30784 }
30785 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 resultobj = SWIG_From_int(static_cast< int >(result));
30793 return resultobj;
30794 fail:
30795 return NULL;
30796 }
30797
30798
30799 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30800 PyObject *resultobj = 0;
30801 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30802 int result;
30803 void *argp1 = 0 ;
30804 int res1 = 0 ;
30805 PyObject *swig_obj[1] ;
30806
30807 if (!args) SWIG_fail;
30808 swig_obj[0] = args;
30809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30810 if (!SWIG_IsOK(res1)) {
30811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30812 }
30813 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30817 wxPyEndAllowThreads(__tstate);
30818 if (PyErr_Occurred()) SWIG_fail;
30819 }
30820 resultobj = SWIG_From_int(static_cast< int >(result));
30821 return resultobj;
30822 fail:
30823 return NULL;
30824 }
30825
30826
30827 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30828 PyObject *resultobj = 0;
30829 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30830 int result;
30831 void *argp1 = 0 ;
30832 int res1 = 0 ;
30833 PyObject *swig_obj[1] ;
30834
30835 if (!args) SWIG_fail;
30836 swig_obj[0] = args;
30837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30838 if (!SWIG_IsOK(res1)) {
30839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30840 }
30841 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30842 {
30843 PyThreadState* __tstate = wxPyBeginAllowThreads();
30844 result = (int)((wxDateSpan const *)arg1)->GetDays();
30845 wxPyEndAllowThreads(__tstate);
30846 if (PyErr_Occurred()) SWIG_fail;
30847 }
30848 resultobj = SWIG_From_int(static_cast< int >(result));
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30856 PyObject *resultobj = 0;
30857 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30858 int result;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 PyObject *swig_obj[1] ;
30862
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 resultobj = SWIG_From_int(static_cast< int >(result));
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30884 PyObject *resultobj = 0;
30885 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30886 wxDateSpan *arg2 = 0 ;
30887 wxDateSpan *result = 0 ;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 void *argp2 = 0 ;
30891 int res2 = 0 ;
30892 PyObject * obj0 = 0 ;
30893 PyObject * obj1 = 0 ;
30894 char * kwnames[] = {
30895 (char *) "self",(char *) "other", NULL
30896 };
30897
30898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30900 if (!SWIG_IsOK(res1)) {
30901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30902 }
30903 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30905 if (!SWIG_IsOK(res2)) {
30906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30907 }
30908 if (!argp2) {
30909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30910 }
30911 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30912 {
30913 PyThreadState* __tstate = wxPyBeginAllowThreads();
30914 {
30915 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30916 result = (wxDateSpan *) &_result_ref;
30917 }
30918 wxPyEndAllowThreads(__tstate);
30919 if (PyErr_Occurred()) SWIG_fail;
30920 }
30921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30922 return resultobj;
30923 fail:
30924 return NULL;
30925 }
30926
30927
30928 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30929 PyObject *resultobj = 0;
30930 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30931 wxDateSpan *arg2 = 0 ;
30932 wxDateSpan *result = 0 ;
30933 void *argp1 = 0 ;
30934 int res1 = 0 ;
30935 void *argp2 = 0 ;
30936 int res2 = 0 ;
30937 PyObject * obj0 = 0 ;
30938 PyObject * obj1 = 0 ;
30939 char * kwnames[] = {
30940 (char *) "self",(char *) "other", NULL
30941 };
30942
30943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30945 if (!SWIG_IsOK(res1)) {
30946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30947 }
30948 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30950 if (!SWIG_IsOK(res2)) {
30951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30952 }
30953 if (!argp2) {
30954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30955 }
30956 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 {
30960 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30961 result = (wxDateSpan *) &_result_ref;
30962 }
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30967 return resultobj;
30968 fail:
30969 return NULL;
30970 }
30971
30972
30973 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30974 PyObject *resultobj = 0;
30975 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30976 wxDateSpan *result = 0 ;
30977 void *argp1 = 0 ;
30978 int res1 = 0 ;
30979 PyObject *swig_obj[1] ;
30980
30981 if (!args) SWIG_fail;
30982 swig_obj[0] = args;
30983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30984 if (!SWIG_IsOK(res1)) {
30985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30986 }
30987 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30988 {
30989 PyThreadState* __tstate = wxPyBeginAllowThreads();
30990 {
30991 wxDateSpan &_result_ref = (arg1)->Neg();
30992 result = (wxDateSpan *) &_result_ref;
30993 }
30994 wxPyEndAllowThreads(__tstate);
30995 if (PyErr_Occurred()) SWIG_fail;
30996 }
30997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30998 return resultobj;
30999 fail:
31000 return NULL;
31001 }
31002
31003
31004 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31005 PyObject *resultobj = 0;
31006 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31007 int arg2 ;
31008 wxDateSpan *result = 0 ;
31009 void *argp1 = 0 ;
31010 int res1 = 0 ;
31011 int val2 ;
31012 int ecode2 = 0 ;
31013 PyObject * obj0 = 0 ;
31014 PyObject * obj1 = 0 ;
31015 char * kwnames[] = {
31016 (char *) "self",(char *) "factor", NULL
31017 };
31018
31019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31021 if (!SWIG_IsOK(res1)) {
31022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31023 }
31024 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31025 ecode2 = SWIG_AsVal_int(obj1, &val2);
31026 if (!SWIG_IsOK(ecode2)) {
31027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31028 }
31029 arg2 = static_cast< int >(val2);
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 {
31033 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31034 result = (wxDateSpan *) &_result_ref;
31035 }
31036 wxPyEndAllowThreads(__tstate);
31037 if (PyErr_Occurred()) SWIG_fail;
31038 }
31039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31040 return resultobj;
31041 fail:
31042 return NULL;
31043 }
31044
31045
31046 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31047 PyObject *resultobj = 0;
31048 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31049 wxDateSpan *arg2 = 0 ;
31050 wxDateSpan *result = 0 ;
31051 void *argp1 = 0 ;
31052 int res1 = 0 ;
31053 void *argp2 = 0 ;
31054 int res2 = 0 ;
31055 PyObject * obj0 = 0 ;
31056 PyObject * obj1 = 0 ;
31057 char * kwnames[] = {
31058 (char *) "self",(char *) "other", NULL
31059 };
31060
31061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31063 if (!SWIG_IsOK(res1)) {
31064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31065 }
31066 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31068 if (!SWIG_IsOK(res2)) {
31069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31070 }
31071 if (!argp2) {
31072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31073 }
31074 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31075 {
31076 PyThreadState* __tstate = wxPyBeginAllowThreads();
31077 {
31078 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31079 result = (wxDateSpan *) &_result_ref;
31080 }
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31085 return resultobj;
31086 fail:
31087 return NULL;
31088 }
31089
31090
31091 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31092 PyObject *resultobj = 0;
31093 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31094 wxDateSpan *arg2 = 0 ;
31095 wxDateSpan *result = 0 ;
31096 void *argp1 = 0 ;
31097 int res1 = 0 ;
31098 void *argp2 = 0 ;
31099 int res2 = 0 ;
31100 PyObject * obj0 = 0 ;
31101 PyObject * obj1 = 0 ;
31102 char * kwnames[] = {
31103 (char *) "self",(char *) "other", NULL
31104 };
31105
31106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31108 if (!SWIG_IsOK(res1)) {
31109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31110 }
31111 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31112 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31113 if (!SWIG_IsOK(res2)) {
31114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31115 }
31116 if (!argp2) {
31117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31118 }
31119 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31120 {
31121 PyThreadState* __tstate = wxPyBeginAllowThreads();
31122 {
31123 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31124 result = (wxDateSpan *) &_result_ref;
31125 }
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31137 PyObject *resultobj = 0;
31138 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31139 wxDateSpan *result = 0 ;
31140 void *argp1 = 0 ;
31141 int res1 = 0 ;
31142 PyObject *swig_obj[1] ;
31143
31144 if (!args) SWIG_fail;
31145 swig_obj[0] = args;
31146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31147 if (!SWIG_IsOK(res1)) {
31148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31149 }
31150 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 {
31154 wxDateSpan &_result_ref = (arg1)->operator -();
31155 result = (wxDateSpan *) &_result_ref;
31156 }
31157 wxPyEndAllowThreads(__tstate);
31158 if (PyErr_Occurred()) SWIG_fail;
31159 }
31160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31161 return resultobj;
31162 fail:
31163 return NULL;
31164 }
31165
31166
31167 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31168 PyObject *resultobj = 0;
31169 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31170 int arg2 ;
31171 wxDateSpan *result = 0 ;
31172 void *argp1 = 0 ;
31173 int res1 = 0 ;
31174 int val2 ;
31175 int ecode2 = 0 ;
31176 PyObject * obj0 = 0 ;
31177 PyObject * obj1 = 0 ;
31178 char * kwnames[] = {
31179 (char *) "self",(char *) "factor", NULL
31180 };
31181
31182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31184 if (!SWIG_IsOK(res1)) {
31185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31186 }
31187 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31188 ecode2 = SWIG_AsVal_int(obj1, &val2);
31189 if (!SWIG_IsOK(ecode2)) {
31190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31191 }
31192 arg2 = static_cast< int >(val2);
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 {
31196 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31197 result = (wxDateSpan *) &_result_ref;
31198 }
31199 wxPyEndAllowThreads(__tstate);
31200 if (PyErr_Occurred()) SWIG_fail;
31201 }
31202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31203 return resultobj;
31204 fail:
31205 return NULL;
31206 }
31207
31208
31209 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31210 PyObject *resultobj = 0;
31211 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31212 wxDateSpan *arg2 = 0 ;
31213 wxDateSpan result;
31214 void *argp1 = 0 ;
31215 int res1 = 0 ;
31216 void *argp2 = 0 ;
31217 int res2 = 0 ;
31218 PyObject * obj0 = 0 ;
31219 PyObject * obj1 = 0 ;
31220 char * kwnames[] = {
31221 (char *) "self",(char *) "other", NULL
31222 };
31223
31224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31226 if (!SWIG_IsOK(res1)) {
31227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31228 }
31229 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31230 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31231 if (!SWIG_IsOK(res2)) {
31232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31233 }
31234 if (!argp2) {
31235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31236 }
31237 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31238 {
31239 PyThreadState* __tstate = wxPyBeginAllowThreads();
31240 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31241 wxPyEndAllowThreads(__tstate);
31242 if (PyErr_Occurred()) SWIG_fail;
31243 }
31244 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31252 PyObject *resultobj = 0;
31253 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31254 wxDateSpan *arg2 = 0 ;
31255 wxDateSpan result;
31256 void *argp1 = 0 ;
31257 int res1 = 0 ;
31258 void *argp2 = 0 ;
31259 int res2 = 0 ;
31260 PyObject * obj0 = 0 ;
31261 PyObject * obj1 = 0 ;
31262 char * kwnames[] = {
31263 (char *) "self",(char *) "other", NULL
31264 };
31265
31266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31268 if (!SWIG_IsOK(res1)) {
31269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31270 }
31271 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31273 if (!SWIG_IsOK(res2)) {
31274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31275 }
31276 if (!argp2) {
31277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31278 }
31279 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31280 {
31281 PyThreadState* __tstate = wxPyBeginAllowThreads();
31282 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31283 wxPyEndAllowThreads(__tstate);
31284 if (PyErr_Occurred()) SWIG_fail;
31285 }
31286 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31287 return resultobj;
31288 fail:
31289 return NULL;
31290 }
31291
31292
31293 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31294 PyObject *resultobj = 0;
31295 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31296 int arg2 ;
31297 wxDateSpan result;
31298 void *argp1 = 0 ;
31299 int res1 = 0 ;
31300 int val2 ;
31301 int ecode2 = 0 ;
31302 PyObject * obj0 = 0 ;
31303 PyObject * obj1 = 0 ;
31304 char * kwnames[] = {
31305 (char *) "self",(char *) "n", NULL
31306 };
31307
31308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31310 if (!SWIG_IsOK(res1)) {
31311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31312 }
31313 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31314 ecode2 = SWIG_AsVal_int(obj1, &val2);
31315 if (!SWIG_IsOK(ecode2)) {
31316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31317 }
31318 arg2 = static_cast< int >(val2);
31319 {
31320 PyThreadState* __tstate = wxPyBeginAllowThreads();
31321 result = wxDateSpan___mul__(arg1,arg2);
31322 wxPyEndAllowThreads(__tstate);
31323 if (PyErr_Occurred()) SWIG_fail;
31324 }
31325 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31326 return resultobj;
31327 fail:
31328 return NULL;
31329 }
31330
31331
31332 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31333 PyObject *resultobj = 0;
31334 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31335 int arg2 ;
31336 wxDateSpan result;
31337 void *argp1 = 0 ;
31338 int res1 = 0 ;
31339 int val2 ;
31340 int ecode2 = 0 ;
31341 PyObject * obj0 = 0 ;
31342 PyObject * obj1 = 0 ;
31343 char * kwnames[] = {
31344 (char *) "self",(char *) "n", NULL
31345 };
31346
31347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31349 if (!SWIG_IsOK(res1)) {
31350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31351 }
31352 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31353 ecode2 = SWIG_AsVal_int(obj1, &val2);
31354 if (!SWIG_IsOK(ecode2)) {
31355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31356 }
31357 arg2 = static_cast< int >(val2);
31358 {
31359 PyThreadState* __tstate = wxPyBeginAllowThreads();
31360 result = wxDateSpan___rmul__(arg1,arg2);
31361 wxPyEndAllowThreads(__tstate);
31362 if (PyErr_Occurred()) SWIG_fail;
31363 }
31364 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31372 PyObject *resultobj = 0;
31373 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31374 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31375 bool result;
31376 void *argp1 = 0 ;
31377 int res1 = 0 ;
31378 void *argp2 = 0 ;
31379 int res2 = 0 ;
31380 PyObject * obj0 = 0 ;
31381 PyObject * obj1 = 0 ;
31382 char * kwnames[] = {
31383 (char *) "self",(char *) "other", NULL
31384 };
31385
31386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31388 if (!SWIG_IsOK(res1)) {
31389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31390 }
31391 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31393 if (!SWIG_IsOK(res2)) {
31394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31395 }
31396 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31397 {
31398 PyThreadState* __tstate = wxPyBeginAllowThreads();
31399 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31400 wxPyEndAllowThreads(__tstate);
31401 if (PyErr_Occurred()) SWIG_fail;
31402 }
31403 {
31404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31405 }
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj = 0;
31414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31415 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31416 bool result;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 void *argp2 = 0 ;
31420 int res2 = 0 ;
31421 PyObject * obj0 = 0 ;
31422 PyObject * obj1 = 0 ;
31423 char * kwnames[] = {
31424 (char *) "self",(char *) "other", NULL
31425 };
31426
31427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31429 if (!SWIG_IsOK(res1)) {
31430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31431 }
31432 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31433 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31434 if (!SWIG_IsOK(res2)) {
31435 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31436 }
31437 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 {
31445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31446 }
31447 return resultobj;
31448 fail:
31449 return NULL;
31450 }
31451
31452
31453 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31454 PyObject *obj;
31455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31456 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31457 return SWIG_Py_Void();
31458 }
31459
31460 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31461 return SWIG_Python_InitShadowInstance(args);
31462 }
31463
31464 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31465 PyObject *resultobj = 0;
31466 long result;
31467
31468 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31469 {
31470 PyThreadState* __tstate = wxPyBeginAllowThreads();
31471 result = (long)wxGetLocalTime();
31472 wxPyEndAllowThreads(__tstate);
31473 if (PyErr_Occurred()) SWIG_fail;
31474 }
31475 resultobj = SWIG_From_long(static_cast< long >(result));
31476 return resultobj;
31477 fail:
31478 return NULL;
31479 }
31480
31481
31482 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31483 PyObject *resultobj = 0;
31484 long result;
31485
31486 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31487 {
31488 PyThreadState* __tstate = wxPyBeginAllowThreads();
31489 result = (long)wxGetUTCTime();
31490 wxPyEndAllowThreads(__tstate);
31491 if (PyErr_Occurred()) SWIG_fail;
31492 }
31493 resultobj = SWIG_From_long(static_cast< long >(result));
31494 return resultobj;
31495 fail:
31496 return NULL;
31497 }
31498
31499
31500 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31501 PyObject *resultobj = 0;
31502 long result;
31503
31504 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31505 {
31506 PyThreadState* __tstate = wxPyBeginAllowThreads();
31507 result = (long)wxGetCurrentTime();
31508 wxPyEndAllowThreads(__tstate);
31509 if (PyErr_Occurred()) SWIG_fail;
31510 }
31511 resultobj = SWIG_From_long(static_cast< long >(result));
31512 return resultobj;
31513 fail:
31514 return NULL;
31515 }
31516
31517
31518 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31519 PyObject *resultobj = 0;
31520 wxLongLong result;
31521
31522 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 result = wxGetLocalTimeMillis();
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 {
31530 PyObject *hi, *lo, *shifter, *shifted;
31531 hi = PyLong_FromLong( (&result)->GetHi() );
31532 lo = PyLong_FromLong( (&result)->GetLo() );
31533 shifter = PyLong_FromLong(32);
31534 shifted = PyNumber_Lshift(hi, shifter);
31535 resultobj = PyNumber_Or(shifted, lo);
31536 Py_DECREF(hi);
31537 Py_DECREF(lo);
31538 Py_DECREF(shifter);
31539 Py_DECREF(shifted);
31540 }
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31548 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31549 return 1;
31550 }
31551
31552
31553 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31554 PyObject *pyobj = 0;
31555
31556 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31557 return pyobj;
31558 }
31559
31560
31561 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31562 PyObject *resultobj = 0;
31563 wxDataFormatId arg1 ;
31564 wxDataFormat *result = 0 ;
31565 int val1 ;
31566 int ecode1 = 0 ;
31567 PyObject * obj0 = 0 ;
31568 char * kwnames[] = {
31569 (char *) "type", NULL
31570 };
31571
31572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31573 ecode1 = SWIG_AsVal_int(obj0, &val1);
31574 if (!SWIG_IsOK(ecode1)) {
31575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31576 }
31577 arg1 = static_cast< wxDataFormatId >(val1);
31578 {
31579 PyThreadState* __tstate = wxPyBeginAllowThreads();
31580 result = (wxDataFormat *)new wxDataFormat(arg1);
31581 wxPyEndAllowThreads(__tstate);
31582 if (PyErr_Occurred()) SWIG_fail;
31583 }
31584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31585 return resultobj;
31586 fail:
31587 return NULL;
31588 }
31589
31590
31591 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj = 0;
31593 wxString *arg1 = 0 ;
31594 wxDataFormat *result = 0 ;
31595 bool temp1 = false ;
31596 PyObject * obj0 = 0 ;
31597 char * kwnames[] = {
31598 (char *) "format", NULL
31599 };
31600
31601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31602 {
31603 arg1 = wxString_in_helper(obj0);
31604 if (arg1 == NULL) SWIG_fail;
31605 temp1 = true;
31606 }
31607 {
31608 PyThreadState* __tstate = wxPyBeginAllowThreads();
31609 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31610 wxPyEndAllowThreads(__tstate);
31611 if (PyErr_Occurred()) SWIG_fail;
31612 }
31613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31614 {
31615 if (temp1)
31616 delete arg1;
31617 }
31618 return resultobj;
31619 fail:
31620 {
31621 if (temp1)
31622 delete arg1;
31623 }
31624 return NULL;
31625 }
31626
31627
31628 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31629 PyObject *resultobj = 0;
31630 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31631 void *argp1 = 0 ;
31632 int res1 = 0 ;
31633 PyObject *swig_obj[1] ;
31634
31635 if (!args) SWIG_fail;
31636 swig_obj[0] = args;
31637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31638 if (!SWIG_IsOK(res1)) {
31639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31640 }
31641 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31642 {
31643 PyThreadState* __tstate = wxPyBeginAllowThreads();
31644 delete arg1;
31645
31646 wxPyEndAllowThreads(__tstate);
31647 if (PyErr_Occurred()) SWIG_fail;
31648 }
31649 resultobj = SWIG_Py_Void();
31650 return resultobj;
31651 fail:
31652 return NULL;
31653 }
31654
31655
31656 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31657 PyObject *resultobj = 0;
31658 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31659 wxDataFormatId arg2 ;
31660 bool result;
31661 void *argp1 = 0 ;
31662 int res1 = 0 ;
31663 int val2 ;
31664 int ecode2 = 0 ;
31665
31666 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31668 if (!SWIG_IsOK(res1)) {
31669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31670 }
31671 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31672 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31673 if (!SWIG_IsOK(ecode2)) {
31674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31675 }
31676 arg2 = static_cast< wxDataFormatId >(val2);
31677 {
31678 PyThreadState* __tstate = wxPyBeginAllowThreads();
31679 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31680 wxPyEndAllowThreads(__tstate);
31681 if (PyErr_Occurred()) SWIG_fail;
31682 }
31683 {
31684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31685 }
31686 return resultobj;
31687 fail:
31688 return NULL;
31689 }
31690
31691
31692 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31693 PyObject *resultobj = 0;
31694 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31695 wxDataFormatId arg2 ;
31696 bool result;
31697 void *argp1 = 0 ;
31698 int res1 = 0 ;
31699 int val2 ;
31700 int ecode2 = 0 ;
31701
31702 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31704 if (!SWIG_IsOK(res1)) {
31705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31706 }
31707 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31708 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31709 if (!SWIG_IsOK(ecode2)) {
31710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31711 }
31712 arg2 = static_cast< wxDataFormatId >(val2);
31713 {
31714 PyThreadState* __tstate = wxPyBeginAllowThreads();
31715 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31716 wxPyEndAllowThreads(__tstate);
31717 if (PyErr_Occurred()) SWIG_fail;
31718 }
31719 {
31720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31721 }
31722 return resultobj;
31723 fail:
31724 return NULL;
31725 }
31726
31727
31728 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31729 PyObject *resultobj = 0;
31730 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31731 wxDataFormat *arg2 = 0 ;
31732 bool result;
31733 void *argp1 = 0 ;
31734 int res1 = 0 ;
31735 void *argp2 = 0 ;
31736 int res2 = 0 ;
31737
31738 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31740 if (!SWIG_IsOK(res1)) {
31741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31742 }
31743 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31744 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31745 if (!SWIG_IsOK(res2)) {
31746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31747 }
31748 if (!argp2) {
31749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31750 }
31751 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31752 {
31753 PyThreadState* __tstate = wxPyBeginAllowThreads();
31754 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31755 wxPyEndAllowThreads(__tstate);
31756 if (PyErr_Occurred()) SWIG_fail;
31757 }
31758 {
31759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31760 }
31761 return resultobj;
31762 fail:
31763 return NULL;
31764 }
31765
31766
31767 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31768 int argc;
31769 PyObject *argv[3];
31770
31771 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31772 --argc;
31773 if (argc == 2) {
31774 int _v = 0;
31775 {
31776 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31777 _v = SWIG_CheckState(res);
31778 }
31779 if (!_v) goto check_1;
31780 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31781 }
31782 check_1:
31783
31784 if (argc == 2) {
31785 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31786 }
31787
31788 fail:
31789 Py_INCREF(Py_NotImplemented);
31790 return Py_NotImplemented;
31791 }
31792
31793
31794 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31795 PyObject *resultobj = 0;
31796 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31797 wxDataFormat *arg2 = 0 ;
31798 bool result;
31799 void *argp1 = 0 ;
31800 int res1 = 0 ;
31801 void *argp2 = 0 ;
31802 int res2 = 0 ;
31803
31804 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31808 }
31809 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31810 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31811 if (!SWIG_IsOK(res2)) {
31812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31813 }
31814 if (!argp2) {
31815 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31816 }
31817 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31818 {
31819 PyThreadState* __tstate = wxPyBeginAllowThreads();
31820 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 {
31825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31826 }
31827 return resultobj;
31828 fail:
31829 return NULL;
31830 }
31831
31832
31833 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31834 int argc;
31835 PyObject *argv[3];
31836
31837 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31838 --argc;
31839 if (argc == 2) {
31840 int _v = 0;
31841 {
31842 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31843 _v = SWIG_CheckState(res);
31844 }
31845 if (!_v) goto check_1;
31846 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31847 }
31848 check_1:
31849
31850 if (argc == 2) {
31851 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31852 }
31853
31854 fail:
31855 Py_INCREF(Py_NotImplemented);
31856 return Py_NotImplemented;
31857 }
31858
31859
31860 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31861 PyObject *resultobj = 0;
31862 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31863 wxDataFormatId arg2 ;
31864 void *argp1 = 0 ;
31865 int res1 = 0 ;
31866 int val2 ;
31867 int ecode2 = 0 ;
31868 PyObject * obj0 = 0 ;
31869 PyObject * obj1 = 0 ;
31870 char * kwnames[] = {
31871 (char *) "self",(char *) "format", NULL
31872 };
31873
31874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31876 if (!SWIG_IsOK(res1)) {
31877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31878 }
31879 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31880 ecode2 = SWIG_AsVal_int(obj1, &val2);
31881 if (!SWIG_IsOK(ecode2)) {
31882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31883 }
31884 arg2 = static_cast< wxDataFormatId >(val2);
31885 {
31886 PyThreadState* __tstate = wxPyBeginAllowThreads();
31887 (arg1)->SetType(arg2);
31888 wxPyEndAllowThreads(__tstate);
31889 if (PyErr_Occurred()) SWIG_fail;
31890 }
31891 resultobj = SWIG_Py_Void();
31892 return resultobj;
31893 fail:
31894 return NULL;
31895 }
31896
31897
31898 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31899 PyObject *resultobj = 0;
31900 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31901 wxDataFormatId result;
31902 void *argp1 = 0 ;
31903 int res1 = 0 ;
31904 PyObject *swig_obj[1] ;
31905
31906 if (!args) SWIG_fail;
31907 swig_obj[0] = args;
31908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31909 if (!SWIG_IsOK(res1)) {
31910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31911 }
31912 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31913 {
31914 PyThreadState* __tstate = wxPyBeginAllowThreads();
31915 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 resultobj = SWIG_From_int(static_cast< int >(result));
31920 return resultobj;
31921 fail:
31922 return NULL;
31923 }
31924
31925
31926 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31927 PyObject *resultobj = 0;
31928 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31929 wxString result;
31930 void *argp1 = 0 ;
31931 int res1 = 0 ;
31932 PyObject *swig_obj[1] ;
31933
31934 if (!args) SWIG_fail;
31935 swig_obj[0] = args;
31936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31937 if (!SWIG_IsOK(res1)) {
31938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31939 }
31940 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 result = ((wxDataFormat const *)arg1)->GetId();
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 {
31948 #if wxUSE_UNICODE
31949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31950 #else
31951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31952 #endif
31953 }
31954 return resultobj;
31955 fail:
31956 return NULL;
31957 }
31958
31959
31960 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31961 PyObject *resultobj = 0;
31962 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31963 wxString *arg2 = 0 ;
31964 void *argp1 = 0 ;
31965 int res1 = 0 ;
31966 bool temp2 = false ;
31967 PyObject * obj0 = 0 ;
31968 PyObject * obj1 = 0 ;
31969 char * kwnames[] = {
31970 (char *) "self",(char *) "format", NULL
31971 };
31972
31973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31975 if (!SWIG_IsOK(res1)) {
31976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31977 }
31978 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31979 {
31980 arg2 = wxString_in_helper(obj1);
31981 if (arg2 == NULL) SWIG_fail;
31982 temp2 = true;
31983 }
31984 {
31985 PyThreadState* __tstate = wxPyBeginAllowThreads();
31986 (arg1)->SetId((wxString const &)*arg2);
31987 wxPyEndAllowThreads(__tstate);
31988 if (PyErr_Occurred()) SWIG_fail;
31989 }
31990 resultobj = SWIG_Py_Void();
31991 {
31992 if (temp2)
31993 delete arg2;
31994 }
31995 return resultobj;
31996 fail:
31997 {
31998 if (temp2)
31999 delete arg2;
32000 }
32001 return NULL;
32002 }
32003
32004
32005 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32006 PyObject *obj;
32007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32008 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
32009 return SWIG_Py_Void();
32010 }
32011
32012 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32013 return SWIG_Python_InitShadowInstance(args);
32014 }
32015
32016 SWIGINTERN int FormatInvalid_set(PyObject *) {
32017 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32018 return 1;
32019 }
32020
32021
32022 SWIGINTERN PyObject *FormatInvalid_get(void) {
32023 PyObject *pyobj = 0;
32024
32025 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32026 return pyobj;
32027 }
32028
32029
32030 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32031 PyObject *resultobj = 0;
32032 wxDataObject *arg1 = (wxDataObject *) 0 ;
32033 void *argp1 = 0 ;
32034 int res1 = 0 ;
32035 PyObject *swig_obj[1] ;
32036
32037 if (!args) SWIG_fail;
32038 swig_obj[0] = args;
32039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32040 if (!SWIG_IsOK(res1)) {
32041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32042 }
32043 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 delete arg1;
32047
32048 wxPyEndAllowThreads(__tstate);
32049 if (PyErr_Occurred()) SWIG_fail;
32050 }
32051 resultobj = SWIG_Py_Void();
32052 return resultobj;
32053 fail:
32054 return NULL;
32055 }
32056
32057
32058 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32059 PyObject *resultobj = 0;
32060 wxDataObject *arg1 = (wxDataObject *) 0 ;
32061 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32062 SwigValueWrapper<wxDataFormat > result;
32063 void *argp1 = 0 ;
32064 int res1 = 0 ;
32065 int val2 ;
32066 int ecode2 = 0 ;
32067 PyObject * obj0 = 0 ;
32068 PyObject * obj1 = 0 ;
32069 char * kwnames[] = {
32070 (char *) "self",(char *) "dir", NULL
32071 };
32072
32073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32075 if (!SWIG_IsOK(res1)) {
32076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32077 }
32078 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32079 if (obj1) {
32080 ecode2 = SWIG_AsVal_int(obj1, &val2);
32081 if (!SWIG_IsOK(ecode2)) {
32082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32083 }
32084 arg2 = static_cast< wxDataObject::Direction >(val2);
32085 }
32086 {
32087 PyThreadState* __tstate = wxPyBeginAllowThreads();
32088 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32089 wxPyEndAllowThreads(__tstate);
32090 if (PyErr_Occurred()) SWIG_fail;
32091 }
32092 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32093 return resultobj;
32094 fail:
32095 return NULL;
32096 }
32097
32098
32099 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32100 PyObject *resultobj = 0;
32101 wxDataObject *arg1 = (wxDataObject *) 0 ;
32102 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32103 size_t result;
32104 void *argp1 = 0 ;
32105 int res1 = 0 ;
32106 int val2 ;
32107 int ecode2 = 0 ;
32108 PyObject * obj0 = 0 ;
32109 PyObject * obj1 = 0 ;
32110 char * kwnames[] = {
32111 (char *) "self",(char *) "dir", NULL
32112 };
32113
32114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32116 if (!SWIG_IsOK(res1)) {
32117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32118 }
32119 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32120 if (obj1) {
32121 ecode2 = SWIG_AsVal_int(obj1, &val2);
32122 if (!SWIG_IsOK(ecode2)) {
32123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32124 }
32125 arg2 = static_cast< wxDataObject::Direction >(val2);
32126 }
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32141 PyObject *resultobj = 0;
32142 wxDataObject *arg1 = (wxDataObject *) 0 ;
32143 wxDataFormat *arg2 = 0 ;
32144 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32145 bool result;
32146 void *argp1 = 0 ;
32147 int res1 = 0 ;
32148 void *argp2 = 0 ;
32149 int res2 = 0 ;
32150 int val3 ;
32151 int ecode3 = 0 ;
32152 PyObject * obj0 = 0 ;
32153 PyObject * obj1 = 0 ;
32154 PyObject * obj2 = 0 ;
32155 char * kwnames[] = {
32156 (char *) "self",(char *) "format",(char *) "dir", NULL
32157 };
32158
32159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32161 if (!SWIG_IsOK(res1)) {
32162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32163 }
32164 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32165 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32166 if (!SWIG_IsOK(res2)) {
32167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32168 }
32169 if (!argp2) {
32170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32171 }
32172 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32173 if (obj2) {
32174 ecode3 = SWIG_AsVal_int(obj2, &val3);
32175 if (!SWIG_IsOK(ecode3)) {
32176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32177 }
32178 arg3 = static_cast< wxDataObject::Direction >(val3);
32179 }
32180 {
32181 PyThreadState* __tstate = wxPyBeginAllowThreads();
32182 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32183 wxPyEndAllowThreads(__tstate);
32184 if (PyErr_Occurred()) SWIG_fail;
32185 }
32186 {
32187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32188 }
32189 return resultobj;
32190 fail:
32191 return NULL;
32192 }
32193
32194
32195 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32196 PyObject *resultobj = 0;
32197 wxDataObject *arg1 = (wxDataObject *) 0 ;
32198 wxDataFormat *arg2 = 0 ;
32199 size_t result;
32200 void *argp1 = 0 ;
32201 int res1 = 0 ;
32202 void *argp2 = 0 ;
32203 int res2 = 0 ;
32204 PyObject * obj0 = 0 ;
32205 PyObject * obj1 = 0 ;
32206 char * kwnames[] = {
32207 (char *) "self",(char *) "format", NULL
32208 };
32209
32210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32212 if (!SWIG_IsOK(res1)) {
32213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32214 }
32215 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32217 if (!SWIG_IsOK(res2)) {
32218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32219 }
32220 if (!argp2) {
32221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32222 }
32223 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32224 {
32225 PyThreadState* __tstate = wxPyBeginAllowThreads();
32226 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32227 wxPyEndAllowThreads(__tstate);
32228 if (PyErr_Occurred()) SWIG_fail;
32229 }
32230 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32231 return resultobj;
32232 fail:
32233 return NULL;
32234 }
32235
32236
32237 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32238 PyObject *resultobj = 0;
32239 wxDataObject *arg1 = (wxDataObject *) 0 ;
32240 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32241 PyObject *result = 0 ;
32242 void *argp1 = 0 ;
32243 int res1 = 0 ;
32244 int val2 ;
32245 int ecode2 = 0 ;
32246 PyObject * obj0 = 0 ;
32247 PyObject * obj1 = 0 ;
32248 char * kwnames[] = {
32249 (char *) "self",(char *) "dir", NULL
32250 };
32251
32252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32254 if (!SWIG_IsOK(res1)) {
32255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32256 }
32257 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32258 if (obj1) {
32259 ecode2 = SWIG_AsVal_int(obj1, &val2);
32260 if (!SWIG_IsOK(ecode2)) {
32261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32262 }
32263 arg2 = static_cast< wxDataObject::Direction >(val2);
32264 }
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32268 wxPyEndAllowThreads(__tstate);
32269 if (PyErr_Occurred()) SWIG_fail;
32270 }
32271 resultobj = result;
32272 return resultobj;
32273 fail:
32274 return NULL;
32275 }
32276
32277
32278 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32279 PyObject *resultobj = 0;
32280 wxDataObject *arg1 = (wxDataObject *) 0 ;
32281 wxDataFormat *arg2 = 0 ;
32282 PyObject *result = 0 ;
32283 void *argp1 = 0 ;
32284 int res1 = 0 ;
32285 void *argp2 = 0 ;
32286 int res2 = 0 ;
32287 PyObject * obj0 = 0 ;
32288 PyObject * obj1 = 0 ;
32289 char * kwnames[] = {
32290 (char *) "self",(char *) "format", NULL
32291 };
32292
32293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32295 if (!SWIG_IsOK(res1)) {
32296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32297 }
32298 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32300 if (!SWIG_IsOK(res2)) {
32301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32302 }
32303 if (!argp2) {
32304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32305 }
32306 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32307 {
32308 PyThreadState* __tstate = wxPyBeginAllowThreads();
32309 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32310 wxPyEndAllowThreads(__tstate);
32311 if (PyErr_Occurred()) SWIG_fail;
32312 }
32313 resultobj = result;
32314 return resultobj;
32315 fail:
32316 return NULL;
32317 }
32318
32319
32320 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32321 PyObject *resultobj = 0;
32322 wxDataObject *arg1 = (wxDataObject *) 0 ;
32323 wxDataFormat *arg2 = 0 ;
32324 PyObject *arg3 = (PyObject *) 0 ;
32325 bool result;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 void *argp2 = 0 ;
32329 int res2 = 0 ;
32330 PyObject * obj0 = 0 ;
32331 PyObject * obj1 = 0 ;
32332 PyObject * obj2 = 0 ;
32333 char * kwnames[] = {
32334 (char *) "self",(char *) "format",(char *) "data", NULL
32335 };
32336
32337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32339 if (!SWIG_IsOK(res1)) {
32340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32341 }
32342 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32343 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32344 if (!SWIG_IsOK(res2)) {
32345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32346 }
32347 if (!argp2) {
32348 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32349 }
32350 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32351 arg3 = obj2;
32352 {
32353 PyThreadState* __tstate = wxPyBeginAllowThreads();
32354 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32355 wxPyEndAllowThreads(__tstate);
32356 if (PyErr_Occurred()) SWIG_fail;
32357 }
32358 {
32359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32360 }
32361 return resultobj;
32362 fail:
32363 return NULL;
32364 }
32365
32366
32367 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32368 PyObject *obj;
32369 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32370 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32371 return SWIG_Py_Void();
32372 }
32373
32374 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32375 PyObject *resultobj = 0;
32376 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32377 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32378 wxDataObjectSimple *result = 0 ;
32379 void *argp1 = 0 ;
32380 int res1 = 0 ;
32381 PyObject * obj0 = 0 ;
32382 char * kwnames[] = {
32383 (char *) "format", NULL
32384 };
32385
32386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32387 if (obj0) {
32388 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32389 if (!SWIG_IsOK(res1)) {
32390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32391 }
32392 if (!argp1) {
32393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32394 }
32395 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32396 }
32397 {
32398 PyThreadState* __tstate = wxPyBeginAllowThreads();
32399 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32400 wxPyEndAllowThreads(__tstate);
32401 if (PyErr_Occurred()) SWIG_fail;
32402 }
32403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32404 return resultobj;
32405 fail:
32406 return NULL;
32407 }
32408
32409
32410 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32411 PyObject *resultobj = 0;
32412 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32413 wxDataFormat *result = 0 ;
32414 void *argp1 = 0 ;
32415 int res1 = 0 ;
32416 PyObject *swig_obj[1] ;
32417
32418 if (!args) SWIG_fail;
32419 swig_obj[0] = args;
32420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32421 if (!SWIG_IsOK(res1)) {
32422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32423 }
32424 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32425 {
32426 PyThreadState* __tstate = wxPyBeginAllowThreads();
32427 {
32428 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32429 result = (wxDataFormat *) &_result_ref;
32430 }
32431 wxPyEndAllowThreads(__tstate);
32432 if (PyErr_Occurred()) SWIG_fail;
32433 }
32434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32442 PyObject *resultobj = 0;
32443 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32444 wxDataFormat *arg2 = 0 ;
32445 void *argp1 = 0 ;
32446 int res1 = 0 ;
32447 void *argp2 = 0 ;
32448 int res2 = 0 ;
32449 PyObject * obj0 = 0 ;
32450 PyObject * obj1 = 0 ;
32451 char * kwnames[] = {
32452 (char *) "self",(char *) "format", NULL
32453 };
32454
32455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32457 if (!SWIG_IsOK(res1)) {
32458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32459 }
32460 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32461 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32462 if (!SWIG_IsOK(res2)) {
32463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32464 }
32465 if (!argp2) {
32466 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32467 }
32468 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 resultobj = SWIG_Py_Void();
32476 return resultobj;
32477 fail:
32478 return NULL;
32479 }
32480
32481
32482 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32483 PyObject *resultobj = 0;
32484 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32485 size_t result;
32486 void *argp1 = 0 ;
32487 int res1 = 0 ;
32488 PyObject *swig_obj[1] ;
32489
32490 if (!args) SWIG_fail;
32491 swig_obj[0] = args;
32492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32493 if (!SWIG_IsOK(res1)) {
32494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32495 }
32496 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32497 {
32498 PyThreadState* __tstate = wxPyBeginAllowThreads();
32499 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32500 wxPyEndAllowThreads(__tstate);
32501 if (PyErr_Occurred()) SWIG_fail;
32502 }
32503 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32504 return resultobj;
32505 fail:
32506 return NULL;
32507 }
32508
32509
32510 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32511 PyObject *resultobj = 0;
32512 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32513 PyObject *result = 0 ;
32514 void *argp1 = 0 ;
32515 int res1 = 0 ;
32516 PyObject *swig_obj[1] ;
32517
32518 if (!args) SWIG_fail;
32519 swig_obj[0] = args;
32520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32521 if (!SWIG_IsOK(res1)) {
32522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32523 }
32524 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32525 {
32526 PyThreadState* __tstate = wxPyBeginAllowThreads();
32527 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32528 wxPyEndAllowThreads(__tstate);
32529 if (PyErr_Occurred()) SWIG_fail;
32530 }
32531 resultobj = result;
32532 return resultobj;
32533 fail:
32534 return NULL;
32535 }
32536
32537
32538 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32539 PyObject *resultobj = 0;
32540 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32541 PyObject *arg2 = (PyObject *) 0 ;
32542 bool result;
32543 void *argp1 = 0 ;
32544 int res1 = 0 ;
32545 PyObject * obj0 = 0 ;
32546 PyObject * obj1 = 0 ;
32547 char * kwnames[] = {
32548 (char *) "self",(char *) "data", NULL
32549 };
32550
32551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32553 if (!SWIG_IsOK(res1)) {
32554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32555 }
32556 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32557 arg2 = obj1;
32558 {
32559 PyThreadState* __tstate = wxPyBeginAllowThreads();
32560 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32561 wxPyEndAllowThreads(__tstate);
32562 if (PyErr_Occurred()) SWIG_fail;
32563 }
32564 {
32565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32566 }
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32574 PyObject *obj;
32575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32576 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32577 return SWIG_Py_Void();
32578 }
32579
32580 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32581 return SWIG_Python_InitShadowInstance(args);
32582 }
32583
32584 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32585 PyObject *resultobj = 0;
32586 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32587 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32588 wxPyDataObjectSimple *result = 0 ;
32589 void *argp1 = 0 ;
32590 int res1 = 0 ;
32591 PyObject * obj0 = 0 ;
32592 char * kwnames[] = {
32593 (char *) "format", NULL
32594 };
32595
32596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32597 if (obj0) {
32598 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32599 if (!SWIG_IsOK(res1)) {
32600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32601 }
32602 if (!argp1) {
32603 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32604 }
32605 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32606 }
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32610 wxPyEndAllowThreads(__tstate);
32611 if (PyErr_Occurred()) SWIG_fail;
32612 }
32613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32621 PyObject *resultobj = 0;
32622 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32623 PyObject *arg2 = (PyObject *) 0 ;
32624 PyObject *arg3 = (PyObject *) 0 ;
32625 void *argp1 = 0 ;
32626 int res1 = 0 ;
32627 PyObject * obj0 = 0 ;
32628 PyObject * obj1 = 0 ;
32629 PyObject * obj2 = 0 ;
32630 char * kwnames[] = {
32631 (char *) "self",(char *) "self",(char *) "_class", NULL
32632 };
32633
32634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32636 if (!SWIG_IsOK(res1)) {
32637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32638 }
32639 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32640 arg2 = obj1;
32641 arg3 = obj2;
32642 {
32643 PyThreadState* __tstate = wxPyBeginAllowThreads();
32644 (arg1)->_setCallbackInfo(arg2,arg3);
32645 wxPyEndAllowThreads(__tstate);
32646 if (PyErr_Occurred()) SWIG_fail;
32647 }
32648 resultobj = SWIG_Py_Void();
32649 return resultobj;
32650 fail:
32651 return NULL;
32652 }
32653
32654
32655 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32656 PyObject *obj;
32657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32658 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32659 return SWIG_Py_Void();
32660 }
32661
32662 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32663 return SWIG_Python_InitShadowInstance(args);
32664 }
32665
32666 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32667 PyObject *resultobj = 0;
32668 wxDataObjectComposite *result = 0 ;
32669
32670 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32671 {
32672 PyThreadState* __tstate = wxPyBeginAllowThreads();
32673 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32674 wxPyEndAllowThreads(__tstate);
32675 if (PyErr_Occurred()) SWIG_fail;
32676 }
32677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32678 return resultobj;
32679 fail:
32680 return NULL;
32681 }
32682
32683
32684 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32685 PyObject *resultobj = 0;
32686 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32687 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32688 bool arg3 = (bool) false ;
32689 void *argp1 = 0 ;
32690 int res1 = 0 ;
32691 int res2 = 0 ;
32692 bool val3 ;
32693 int ecode3 = 0 ;
32694 PyObject * obj0 = 0 ;
32695 PyObject * obj1 = 0 ;
32696 PyObject * obj2 = 0 ;
32697 char * kwnames[] = {
32698 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32699 };
32700
32701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32705 }
32706 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32707 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32708 if (!SWIG_IsOK(res2)) {
32709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32710 }
32711 if (obj2) {
32712 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32713 if (!SWIG_IsOK(ecode3)) {
32714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32715 }
32716 arg3 = static_cast< bool >(val3);
32717 }
32718 {
32719 PyThreadState* __tstate = wxPyBeginAllowThreads();
32720 (arg1)->Add(arg2,arg3);
32721 wxPyEndAllowThreads(__tstate);
32722 if (PyErr_Occurred()) SWIG_fail;
32723 }
32724 resultobj = SWIG_Py_Void();
32725 return resultobj;
32726 fail:
32727 return NULL;
32728 }
32729
32730
32731 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32732 PyObject *resultobj = 0;
32733 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32734 SwigValueWrapper<wxDataFormat > result;
32735 void *argp1 = 0 ;
32736 int res1 = 0 ;
32737 PyObject *swig_obj[1] ;
32738
32739 if (!args) SWIG_fail;
32740 swig_obj[0] = args;
32741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32742 if (!SWIG_IsOK(res1)) {
32743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32744 }
32745 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32746 {
32747 PyThreadState* __tstate = wxPyBeginAllowThreads();
32748 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32749 wxPyEndAllowThreads(__tstate);
32750 if (PyErr_Occurred()) SWIG_fail;
32751 }
32752 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32753 return resultobj;
32754 fail:
32755 return NULL;
32756 }
32757
32758
32759 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32760 PyObject *obj;
32761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32762 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32763 return SWIG_Py_Void();
32764 }
32765
32766 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32767 return SWIG_Python_InitShadowInstance(args);
32768 }
32769
32770 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32771 PyObject *resultobj = 0;
32772 wxString const &arg1_defvalue = wxPyEmptyString ;
32773 wxString *arg1 = (wxString *) &arg1_defvalue ;
32774 wxTextDataObject *result = 0 ;
32775 bool temp1 = false ;
32776 PyObject * obj0 = 0 ;
32777 char * kwnames[] = {
32778 (char *) "text", NULL
32779 };
32780
32781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32782 if (obj0) {
32783 {
32784 arg1 = wxString_in_helper(obj0);
32785 if (arg1 == NULL) SWIG_fail;
32786 temp1 = true;
32787 }
32788 }
32789 {
32790 PyThreadState* __tstate = wxPyBeginAllowThreads();
32791 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32792 wxPyEndAllowThreads(__tstate);
32793 if (PyErr_Occurred()) SWIG_fail;
32794 }
32795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32796 {
32797 if (temp1)
32798 delete arg1;
32799 }
32800 return resultobj;
32801 fail:
32802 {
32803 if (temp1)
32804 delete arg1;
32805 }
32806 return NULL;
32807 }
32808
32809
32810 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32811 PyObject *resultobj = 0;
32812 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32813 size_t result;
32814 void *argp1 = 0 ;
32815 int res1 = 0 ;
32816 PyObject *swig_obj[1] ;
32817
32818 if (!args) SWIG_fail;
32819 swig_obj[0] = args;
32820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32821 if (!SWIG_IsOK(res1)) {
32822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32823 }
32824 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32825 {
32826 PyThreadState* __tstate = wxPyBeginAllowThreads();
32827 result = (size_t)(arg1)->GetTextLength();
32828 wxPyEndAllowThreads(__tstate);
32829 if (PyErr_Occurred()) SWIG_fail;
32830 }
32831 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32832 return resultobj;
32833 fail:
32834 return NULL;
32835 }
32836
32837
32838 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32839 PyObject *resultobj = 0;
32840 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32841 wxString result;
32842 void *argp1 = 0 ;
32843 int res1 = 0 ;
32844 PyObject *swig_obj[1] ;
32845
32846 if (!args) SWIG_fail;
32847 swig_obj[0] = args;
32848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32849 if (!SWIG_IsOK(res1)) {
32850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32851 }
32852 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32853 {
32854 PyThreadState* __tstate = wxPyBeginAllowThreads();
32855 result = (arg1)->GetText();
32856 wxPyEndAllowThreads(__tstate);
32857 if (PyErr_Occurred()) SWIG_fail;
32858 }
32859 {
32860 #if wxUSE_UNICODE
32861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32862 #else
32863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32864 #endif
32865 }
32866 return resultobj;
32867 fail:
32868 return NULL;
32869 }
32870
32871
32872 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32873 PyObject *resultobj = 0;
32874 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32875 wxString *arg2 = 0 ;
32876 void *argp1 = 0 ;
32877 int res1 = 0 ;
32878 bool temp2 = false ;
32879 PyObject * obj0 = 0 ;
32880 PyObject * obj1 = 0 ;
32881 char * kwnames[] = {
32882 (char *) "self",(char *) "text", NULL
32883 };
32884
32885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32889 }
32890 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32891 {
32892 arg2 = wxString_in_helper(obj1);
32893 if (arg2 == NULL) SWIG_fail;
32894 temp2 = true;
32895 }
32896 {
32897 PyThreadState* __tstate = wxPyBeginAllowThreads();
32898 (arg1)->SetText((wxString const &)*arg2);
32899 wxPyEndAllowThreads(__tstate);
32900 if (PyErr_Occurred()) SWIG_fail;
32901 }
32902 resultobj = SWIG_Py_Void();
32903 {
32904 if (temp2)
32905 delete arg2;
32906 }
32907 return resultobj;
32908 fail:
32909 {
32910 if (temp2)
32911 delete arg2;
32912 }
32913 return NULL;
32914 }
32915
32916
32917 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32918 PyObject *obj;
32919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32920 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32921 return SWIG_Py_Void();
32922 }
32923
32924 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32925 return SWIG_Python_InitShadowInstance(args);
32926 }
32927
32928 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32929 PyObject *resultobj = 0;
32930 wxString const &arg1_defvalue = wxPyEmptyString ;
32931 wxString *arg1 = (wxString *) &arg1_defvalue ;
32932 wxPyTextDataObject *result = 0 ;
32933 bool temp1 = false ;
32934 PyObject * obj0 = 0 ;
32935 char * kwnames[] = {
32936 (char *) "text", NULL
32937 };
32938
32939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32940 if (obj0) {
32941 {
32942 arg1 = wxString_in_helper(obj0);
32943 if (arg1 == NULL) SWIG_fail;
32944 temp1 = true;
32945 }
32946 }
32947 {
32948 PyThreadState* __tstate = wxPyBeginAllowThreads();
32949 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32950 wxPyEndAllowThreads(__tstate);
32951 if (PyErr_Occurred()) SWIG_fail;
32952 }
32953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32954 {
32955 if (temp1)
32956 delete arg1;
32957 }
32958 return resultobj;
32959 fail:
32960 {
32961 if (temp1)
32962 delete arg1;
32963 }
32964 return NULL;
32965 }
32966
32967
32968 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32969 PyObject *resultobj = 0;
32970 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32971 PyObject *arg2 = (PyObject *) 0 ;
32972 PyObject *arg3 = (PyObject *) 0 ;
32973 void *argp1 = 0 ;
32974 int res1 = 0 ;
32975 PyObject * obj0 = 0 ;
32976 PyObject * obj1 = 0 ;
32977 PyObject * obj2 = 0 ;
32978 char * kwnames[] = {
32979 (char *) "self",(char *) "self",(char *) "_class", NULL
32980 };
32981
32982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32984 if (!SWIG_IsOK(res1)) {
32985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32986 }
32987 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32988 arg2 = obj1;
32989 arg3 = obj2;
32990 {
32991 PyThreadState* __tstate = wxPyBeginAllowThreads();
32992 (arg1)->_setCallbackInfo(arg2,arg3);
32993 wxPyEndAllowThreads(__tstate);
32994 if (PyErr_Occurred()) SWIG_fail;
32995 }
32996 resultobj = SWIG_Py_Void();
32997 return resultobj;
32998 fail:
32999 return NULL;
33000 }
33001
33002
33003 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33004 PyObject *obj;
33005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33006 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
33007 return SWIG_Py_Void();
33008 }
33009
33010 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33011 return SWIG_Python_InitShadowInstance(args);
33012 }
33013
33014 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33015 PyObject *resultobj = 0;
33016 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33017 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33018 wxBitmapDataObject *result = 0 ;
33019 void *argp1 = 0 ;
33020 int res1 = 0 ;
33021 PyObject * obj0 = 0 ;
33022 char * kwnames[] = {
33023 (char *) "bitmap", NULL
33024 };
33025
33026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33027 if (obj0) {
33028 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33029 if (!SWIG_IsOK(res1)) {
33030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33031 }
33032 if (!argp1) {
33033 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33034 }
33035 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33036 }
33037 {
33038 PyThreadState* __tstate = wxPyBeginAllowThreads();
33039 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33040 wxPyEndAllowThreads(__tstate);
33041 if (PyErr_Occurred()) SWIG_fail;
33042 }
33043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33044 return resultobj;
33045 fail:
33046 return NULL;
33047 }
33048
33049
33050 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33051 PyObject *resultobj = 0;
33052 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33053 wxBitmap result;
33054 void *argp1 = 0 ;
33055 int res1 = 0 ;
33056 PyObject *swig_obj[1] ;
33057
33058 if (!args) SWIG_fail;
33059 swig_obj[0] = args;
33060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33061 if (!SWIG_IsOK(res1)) {
33062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33063 }
33064 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33068 wxPyEndAllowThreads(__tstate);
33069 if (PyErr_Occurred()) SWIG_fail;
33070 }
33071 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33072 return resultobj;
33073 fail:
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33079 PyObject *resultobj = 0;
33080 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33081 wxBitmap *arg2 = 0 ;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 void *argp2 = 0 ;
33085 int res2 = 0 ;
33086 PyObject * obj0 = 0 ;
33087 PyObject * obj1 = 0 ;
33088 char * kwnames[] = {
33089 (char *) "self",(char *) "bitmap", NULL
33090 };
33091
33092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33094 if (!SWIG_IsOK(res1)) {
33095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33096 }
33097 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33099 if (!SWIG_IsOK(res2)) {
33100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33101 }
33102 if (!argp2) {
33103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33104 }
33105 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33109 wxPyEndAllowThreads(__tstate);
33110 if (PyErr_Occurred()) SWIG_fail;
33111 }
33112 resultobj = SWIG_Py_Void();
33113 return resultobj;
33114 fail:
33115 return NULL;
33116 }
33117
33118
33119 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33120 PyObject *obj;
33121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33122 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33123 return SWIG_Py_Void();
33124 }
33125
33126 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33127 return SWIG_Python_InitShadowInstance(args);
33128 }
33129
33130 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33131 PyObject *resultobj = 0;
33132 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33133 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33134 wxPyBitmapDataObject *result = 0 ;
33135 void *argp1 = 0 ;
33136 int res1 = 0 ;
33137 PyObject * obj0 = 0 ;
33138 char * kwnames[] = {
33139 (char *) "bitmap", NULL
33140 };
33141
33142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33143 if (obj0) {
33144 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33145 if (!SWIG_IsOK(res1)) {
33146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33147 }
33148 if (!argp1) {
33149 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33150 }
33151 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33152 }
33153 {
33154 PyThreadState* __tstate = wxPyBeginAllowThreads();
33155 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33156 wxPyEndAllowThreads(__tstate);
33157 if (PyErr_Occurred()) SWIG_fail;
33158 }
33159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33160 return resultobj;
33161 fail:
33162 return NULL;
33163 }
33164
33165
33166 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33167 PyObject *resultobj = 0;
33168 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33169 PyObject *arg2 = (PyObject *) 0 ;
33170 PyObject *arg3 = (PyObject *) 0 ;
33171 void *argp1 = 0 ;
33172 int res1 = 0 ;
33173 PyObject * obj0 = 0 ;
33174 PyObject * obj1 = 0 ;
33175 PyObject * obj2 = 0 ;
33176 char * kwnames[] = {
33177 (char *) "self",(char *) "self",(char *) "_class", NULL
33178 };
33179
33180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33182 if (!SWIG_IsOK(res1)) {
33183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33184 }
33185 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33186 arg2 = obj1;
33187 arg3 = obj2;
33188 {
33189 PyThreadState* __tstate = wxPyBeginAllowThreads();
33190 (arg1)->_setCallbackInfo(arg2,arg3);
33191 wxPyEndAllowThreads(__tstate);
33192 if (PyErr_Occurred()) SWIG_fail;
33193 }
33194 resultobj = SWIG_Py_Void();
33195 return resultobj;
33196 fail:
33197 return NULL;
33198 }
33199
33200
33201 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33202 PyObject *obj;
33203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33204 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33205 return SWIG_Py_Void();
33206 }
33207
33208 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33209 return SWIG_Python_InitShadowInstance(args);
33210 }
33211
33212 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33213 PyObject *resultobj = 0;
33214 wxFileDataObject *result = 0 ;
33215
33216 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33217 {
33218 PyThreadState* __tstate = wxPyBeginAllowThreads();
33219 result = (wxFileDataObject *)new wxFileDataObject();
33220 wxPyEndAllowThreads(__tstate);
33221 if (PyErr_Occurred()) SWIG_fail;
33222 }
33223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33224 return resultobj;
33225 fail:
33226 return NULL;
33227 }
33228
33229
33230 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33231 PyObject *resultobj = 0;
33232 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33233 wxArrayString *result = 0 ;
33234 void *argp1 = 0 ;
33235 int res1 = 0 ;
33236 PyObject *swig_obj[1] ;
33237
33238 if (!args) SWIG_fail;
33239 swig_obj[0] = args;
33240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33241 if (!SWIG_IsOK(res1)) {
33242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33243 }
33244 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33245 {
33246 PyThreadState* __tstate = wxPyBeginAllowThreads();
33247 {
33248 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33249 result = (wxArrayString *) &_result_ref;
33250 }
33251 wxPyEndAllowThreads(__tstate);
33252 if (PyErr_Occurred()) SWIG_fail;
33253 }
33254 {
33255 resultobj = wxArrayString2PyList_helper(*result);
33256 }
33257 return resultobj;
33258 fail:
33259 return NULL;
33260 }
33261
33262
33263 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33264 PyObject *resultobj = 0;
33265 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33266 wxString *arg2 = 0 ;
33267 void *argp1 = 0 ;
33268 int res1 = 0 ;
33269 bool temp2 = false ;
33270 PyObject * obj0 = 0 ;
33271 PyObject * obj1 = 0 ;
33272 char * kwnames[] = {
33273 (char *) "self",(char *) "filename", NULL
33274 };
33275
33276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33278 if (!SWIG_IsOK(res1)) {
33279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33280 }
33281 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33282 {
33283 arg2 = wxString_in_helper(obj1);
33284 if (arg2 == NULL) SWIG_fail;
33285 temp2 = true;
33286 }
33287 {
33288 PyThreadState* __tstate = wxPyBeginAllowThreads();
33289 (arg1)->AddFile((wxString const &)*arg2);
33290 wxPyEndAllowThreads(__tstate);
33291 if (PyErr_Occurred()) SWIG_fail;
33292 }
33293 resultobj = SWIG_Py_Void();
33294 {
33295 if (temp2)
33296 delete arg2;
33297 }
33298 return resultobj;
33299 fail:
33300 {
33301 if (temp2)
33302 delete arg2;
33303 }
33304 return NULL;
33305 }
33306
33307
33308 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33309 PyObject *obj;
33310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33311 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33312 return SWIG_Py_Void();
33313 }
33314
33315 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33316 return SWIG_Python_InitShadowInstance(args);
33317 }
33318
33319 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33320 PyObject *resultobj = 0;
33321 wxDataFormat *arg1 = 0 ;
33322 wxCustomDataObject *result = 0 ;
33323 void *argp1 = 0 ;
33324 int res1 = 0 ;
33325
33326 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33328 if (!SWIG_IsOK(res1)) {
33329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33330 }
33331 if (!argp1) {
33332 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33333 }
33334 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33342 return resultobj;
33343 fail:
33344 return NULL;
33345 }
33346
33347
33348 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33349 PyObject *resultobj = 0;
33350 wxString *arg1 = 0 ;
33351 wxCustomDataObject *result = 0 ;
33352 bool temp1 = false ;
33353
33354 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33355 {
33356 arg1 = wxString_in_helper(swig_obj[0]);
33357 if (arg1 == NULL) SWIG_fail;
33358 temp1 = true;
33359 }
33360 {
33361 PyThreadState* __tstate = wxPyBeginAllowThreads();
33362 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33363 wxPyEndAllowThreads(__tstate);
33364 if (PyErr_Occurred()) SWIG_fail;
33365 }
33366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33367 {
33368 if (temp1)
33369 delete arg1;
33370 }
33371 return resultobj;
33372 fail:
33373 {
33374 if (temp1)
33375 delete arg1;
33376 }
33377 return NULL;
33378 }
33379
33380
33381 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33382 PyObject *resultobj = 0;
33383 wxCustomDataObject *result = 0 ;
33384
33385 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (wxCustomDataObject *)new wxCustomDataObject();
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33393 return resultobj;
33394 fail:
33395 return NULL;
33396 }
33397
33398
33399 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33400 int argc;
33401 PyObject *argv[2];
33402
33403 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33404 --argc;
33405 if (argc == 0) {
33406 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33407 }
33408 if (argc == 1) {
33409 int _v = 0;
33410 {
33411 {
33412 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33413 }
33414 }
33415 if (!_v) goto check_2;
33416 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33417 }
33418 check_2:
33419
33420 if (argc == 1) {
33421 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33422 }
33423
33424 fail:
33425 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33426 return NULL;
33427 }
33428
33429
33430 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33431 PyObject *resultobj = 0;
33432 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33433 PyObject *arg2 = (PyObject *) 0 ;
33434 bool result;
33435 void *argp1 = 0 ;
33436 int res1 = 0 ;
33437 PyObject * obj0 = 0 ;
33438 PyObject * obj1 = 0 ;
33439 char * kwnames[] = {
33440 (char *) "self",(char *) "data", NULL
33441 };
33442
33443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33445 if (!SWIG_IsOK(res1)) {
33446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33447 }
33448 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33449 arg2 = obj1;
33450 {
33451 PyThreadState* __tstate = wxPyBeginAllowThreads();
33452 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33453 wxPyEndAllowThreads(__tstate);
33454 if (PyErr_Occurred()) SWIG_fail;
33455 }
33456 {
33457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33458 }
33459 return resultobj;
33460 fail:
33461 return NULL;
33462 }
33463
33464
33465 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33466 PyObject *resultobj = 0;
33467 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33468 size_t result;
33469 void *argp1 = 0 ;
33470 int res1 = 0 ;
33471 PyObject *swig_obj[1] ;
33472
33473 if (!args) SWIG_fail;
33474 swig_obj[0] = args;
33475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33476 if (!SWIG_IsOK(res1)) {
33477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33478 }
33479 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33480 {
33481 PyThreadState* __tstate = wxPyBeginAllowThreads();
33482 result = (size_t)(arg1)->GetSize();
33483 wxPyEndAllowThreads(__tstate);
33484 if (PyErr_Occurred()) SWIG_fail;
33485 }
33486 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33487 return resultobj;
33488 fail:
33489 return NULL;
33490 }
33491
33492
33493 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33494 PyObject *resultobj = 0;
33495 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33496 PyObject *result = 0 ;
33497 void *argp1 = 0 ;
33498 int res1 = 0 ;
33499 PyObject *swig_obj[1] ;
33500
33501 if (!args) SWIG_fail;
33502 swig_obj[0] = args;
33503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33504 if (!SWIG_IsOK(res1)) {
33505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33506 }
33507 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 resultobj = result;
33515 return resultobj;
33516 fail:
33517 return NULL;
33518 }
33519
33520
33521 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33522 PyObject *obj;
33523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33524 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33525 return SWIG_Py_Void();
33526 }
33527
33528 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33529 return SWIG_Python_InitShadowInstance(args);
33530 }
33531
33532 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33533 PyObject *resultobj = 0;
33534 wxString const &arg1_defvalue = wxPyEmptyString ;
33535 wxString *arg1 = (wxString *) &arg1_defvalue ;
33536 wxURLDataObject *result = 0 ;
33537 bool temp1 = false ;
33538 PyObject * obj0 = 0 ;
33539 char * kwnames[] = {
33540 (char *) "url", NULL
33541 };
33542
33543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33544 if (obj0) {
33545 {
33546 arg1 = wxString_in_helper(obj0);
33547 if (arg1 == NULL) SWIG_fail;
33548 temp1 = true;
33549 }
33550 }
33551 {
33552 PyThreadState* __tstate = wxPyBeginAllowThreads();
33553 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33554 wxPyEndAllowThreads(__tstate);
33555 if (PyErr_Occurred()) SWIG_fail;
33556 }
33557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33558 {
33559 if (temp1)
33560 delete arg1;
33561 }
33562 return resultobj;
33563 fail:
33564 {
33565 if (temp1)
33566 delete arg1;
33567 }
33568 return NULL;
33569 }
33570
33571
33572 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33573 PyObject *resultobj = 0;
33574 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33575 wxString result;
33576 void *argp1 = 0 ;
33577 int res1 = 0 ;
33578 PyObject *swig_obj[1] ;
33579
33580 if (!args) SWIG_fail;
33581 swig_obj[0] = args;
33582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33583 if (!SWIG_IsOK(res1)) {
33584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33585 }
33586 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33587 {
33588 PyThreadState* __tstate = wxPyBeginAllowThreads();
33589 result = (arg1)->GetURL();
33590 wxPyEndAllowThreads(__tstate);
33591 if (PyErr_Occurred()) SWIG_fail;
33592 }
33593 {
33594 #if wxUSE_UNICODE
33595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33596 #else
33597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33598 #endif
33599 }
33600 return resultobj;
33601 fail:
33602 return NULL;
33603 }
33604
33605
33606 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33607 PyObject *resultobj = 0;
33608 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33609 wxString *arg2 = 0 ;
33610 void *argp1 = 0 ;
33611 int res1 = 0 ;
33612 bool temp2 = false ;
33613 PyObject * obj0 = 0 ;
33614 PyObject * obj1 = 0 ;
33615 char * kwnames[] = {
33616 (char *) "self",(char *) "url", NULL
33617 };
33618
33619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33621 if (!SWIG_IsOK(res1)) {
33622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33623 }
33624 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33625 {
33626 arg2 = wxString_in_helper(obj1);
33627 if (arg2 == NULL) SWIG_fail;
33628 temp2 = true;
33629 }
33630 {
33631 PyThreadState* __tstate = wxPyBeginAllowThreads();
33632 (arg1)->SetURL((wxString const &)*arg2);
33633 wxPyEndAllowThreads(__tstate);
33634 if (PyErr_Occurred()) SWIG_fail;
33635 }
33636 resultobj = SWIG_Py_Void();
33637 {
33638 if (temp2)
33639 delete arg2;
33640 }
33641 return resultobj;
33642 fail:
33643 {
33644 if (temp2)
33645 delete arg2;
33646 }
33647 return NULL;
33648 }
33649
33650
33651 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33652 PyObject *obj;
33653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33654 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33655 return SWIG_Py_Void();
33656 }
33657
33658 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33659 return SWIG_Python_InitShadowInstance(args);
33660 }
33661
33662 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33663 PyObject *resultobj = 0;
33664 wxMetafileDataObject *result = 0 ;
33665
33666 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33667 {
33668 PyThreadState* __tstate = wxPyBeginAllowThreads();
33669 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33670 wxPyEndAllowThreads(__tstate);
33671 if (PyErr_Occurred()) SWIG_fail;
33672 }
33673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33674 return resultobj;
33675 fail:
33676 return NULL;
33677 }
33678
33679
33680 SWIGINTERN PyObject *MetafileDataObject_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_wxMetafileDataObject, SWIG_NewClientData(obj));
33684 return SWIG_Py_Void();
33685 }
33686
33687 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33688 return SWIG_Python_InitShadowInstance(args);
33689 }
33690
33691 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33692 PyObject *resultobj = 0;
33693 wxDragResult arg1 ;
33694 bool result;
33695 int val1 ;
33696 int ecode1 = 0 ;
33697 PyObject * obj0 = 0 ;
33698 char * kwnames[] = {
33699 (char *) "res", NULL
33700 };
33701
33702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33703 ecode1 = SWIG_AsVal_int(obj0, &val1);
33704 if (!SWIG_IsOK(ecode1)) {
33705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33706 }
33707 arg1 = static_cast< wxDragResult >(val1);
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = (bool)wxIsDragResultOk(arg1);
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 {
33715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33716 }
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj = 0;
33725 wxWindow *arg1 = (wxWindow *) 0 ;
33726 wxIcon const &arg2_defvalue = wxNullIcon ;
33727 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33728 wxIcon const &arg3_defvalue = wxNullIcon ;
33729 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33730 wxIcon const &arg4_defvalue = wxNullIcon ;
33731 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33732 wxPyDropSource *result = 0 ;
33733 void *argp1 = 0 ;
33734 int res1 = 0 ;
33735 void *argp2 = 0 ;
33736 int res2 = 0 ;
33737 void *argp3 = 0 ;
33738 int res3 = 0 ;
33739 void *argp4 = 0 ;
33740 int res4 = 0 ;
33741 PyObject * obj0 = 0 ;
33742 PyObject * obj1 = 0 ;
33743 PyObject * obj2 = 0 ;
33744 PyObject * obj3 = 0 ;
33745 char * kwnames[] = {
33746 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33747 };
33748
33749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33751 if (!SWIG_IsOK(res1)) {
33752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33753 }
33754 arg1 = reinterpret_cast< wxWindow * >(argp1);
33755 if (obj1) {
33756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33757 if (!SWIG_IsOK(res2)) {
33758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33759 }
33760 if (!argp2) {
33761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33762 }
33763 arg2 = reinterpret_cast< wxIcon * >(argp2);
33764 }
33765 if (obj2) {
33766 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33767 if (!SWIG_IsOK(res3)) {
33768 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33769 }
33770 if (!argp3) {
33771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33772 }
33773 arg3 = reinterpret_cast< wxIcon * >(argp3);
33774 }
33775 if (obj3) {
33776 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33777 if (!SWIG_IsOK(res4)) {
33778 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33779 }
33780 if (!argp4) {
33781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33782 }
33783 arg4 = reinterpret_cast< wxIcon * >(argp4);
33784 }
33785 {
33786 PyThreadState* __tstate = wxPyBeginAllowThreads();
33787 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33788 wxPyEndAllowThreads(__tstate);
33789 if (PyErr_Occurred()) SWIG_fail;
33790 }
33791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33792 return resultobj;
33793 fail:
33794 return NULL;
33795 }
33796
33797
33798 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33799 PyObject *resultobj = 0;
33800 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33801 PyObject *arg2 = (PyObject *) 0 ;
33802 PyObject *arg3 = (PyObject *) 0 ;
33803 int arg4 = (int) 0 ;
33804 void *argp1 = 0 ;
33805 int res1 = 0 ;
33806 int val4 ;
33807 int ecode4 = 0 ;
33808 PyObject * obj0 = 0 ;
33809 PyObject * obj1 = 0 ;
33810 PyObject * obj2 = 0 ;
33811 PyObject * obj3 = 0 ;
33812 char * kwnames[] = {
33813 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33814 };
33815
33816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33818 if (!SWIG_IsOK(res1)) {
33819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33820 }
33821 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33822 arg2 = obj1;
33823 arg3 = obj2;
33824 if (obj3) {
33825 ecode4 = SWIG_AsVal_int(obj3, &val4);
33826 if (!SWIG_IsOK(ecode4)) {
33827 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33828 }
33829 arg4 = static_cast< int >(val4);
33830 }
33831 {
33832 PyThreadState* __tstate = wxPyBeginAllowThreads();
33833 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33834 wxPyEndAllowThreads(__tstate);
33835 if (PyErr_Occurred()) SWIG_fail;
33836 }
33837 resultobj = SWIG_Py_Void();
33838 return resultobj;
33839 fail:
33840 return NULL;
33841 }
33842
33843
33844 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33845 PyObject *resultobj = 0;
33846 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33847 void *argp1 = 0 ;
33848 int res1 = 0 ;
33849 PyObject *swig_obj[1] ;
33850
33851 if (!args) SWIG_fail;
33852 swig_obj[0] = args;
33853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33854 if (!SWIG_IsOK(res1)) {
33855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33856 }
33857 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33858 {
33859 PyThreadState* __tstate = wxPyBeginAllowThreads();
33860 delete arg1;
33861
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_Py_Void();
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj = 0;
33874 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33875 wxDataObject *arg2 = 0 ;
33876 void *argp1 = 0 ;
33877 int res1 = 0 ;
33878 void *argp2 = 0 ;
33879 int res2 = 0 ;
33880 PyObject * obj0 = 0 ;
33881 PyObject * obj1 = 0 ;
33882 char * kwnames[] = {
33883 (char *) "self",(char *) "data", NULL
33884 };
33885
33886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33888 if (!SWIG_IsOK(res1)) {
33889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33890 }
33891 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33892 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33893 if (!SWIG_IsOK(res2)) {
33894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33895 }
33896 if (!argp2) {
33897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33898 }
33899 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 (arg1)->SetData(*arg2);
33903 wxPyEndAllowThreads(__tstate);
33904 if (PyErr_Occurred()) SWIG_fail;
33905 }
33906 resultobj = SWIG_Py_Void();
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33914 PyObject *resultobj = 0;
33915 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33916 wxDataObject *result = 0 ;
33917 void *argp1 = 0 ;
33918 int res1 = 0 ;
33919 PyObject *swig_obj[1] ;
33920
33921 if (!args) SWIG_fail;
33922 swig_obj[0] = args;
33923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33924 if (!SWIG_IsOK(res1)) {
33925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33926 }
33927 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 result = (wxDataObject *)(arg1)->GetDataObject();
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33935 return resultobj;
33936 fail:
33937 return NULL;
33938 }
33939
33940
33941 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33942 PyObject *resultobj = 0;
33943 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33944 wxDragResult arg2 ;
33945 wxCursor *arg3 = 0 ;
33946 void *argp1 = 0 ;
33947 int res1 = 0 ;
33948 int val2 ;
33949 int ecode2 = 0 ;
33950 void *argp3 = 0 ;
33951 int res3 = 0 ;
33952 PyObject * obj0 = 0 ;
33953 PyObject * obj1 = 0 ;
33954 PyObject * obj2 = 0 ;
33955 char * kwnames[] = {
33956 (char *) "self",(char *) "res",(char *) "cursor", NULL
33957 };
33958
33959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33961 if (!SWIG_IsOK(res1)) {
33962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33963 }
33964 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33965 ecode2 = SWIG_AsVal_int(obj1, &val2);
33966 if (!SWIG_IsOK(ecode2)) {
33967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33968 }
33969 arg2 = static_cast< wxDragResult >(val2);
33970 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33971 if (!SWIG_IsOK(res3)) {
33972 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33973 }
33974 if (!argp3) {
33975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33976 }
33977 arg3 = reinterpret_cast< wxCursor * >(argp3);
33978 {
33979 PyThreadState* __tstate = wxPyBeginAllowThreads();
33980 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33981 wxPyEndAllowThreads(__tstate);
33982 if (PyErr_Occurred()) SWIG_fail;
33983 }
33984 resultobj = SWIG_Py_Void();
33985 return resultobj;
33986 fail:
33987 return NULL;
33988 }
33989
33990
33991 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33992 PyObject *resultobj = 0;
33993 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33994 int arg2 = (int) wxDrag_CopyOnly ;
33995 wxDragResult result;
33996 void *argp1 = 0 ;
33997 int res1 = 0 ;
33998 int val2 ;
33999 int ecode2 = 0 ;
34000 PyObject * obj0 = 0 ;
34001 PyObject * obj1 = 0 ;
34002 char * kwnames[] = {
34003 (char *) "self",(char *) "flags", NULL
34004 };
34005
34006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
34007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34008 if (!SWIG_IsOK(res1)) {
34009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34010 }
34011 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34012 if (obj1) {
34013 ecode2 = SWIG_AsVal_int(obj1, &val2);
34014 if (!SWIG_IsOK(ecode2)) {
34015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
34016 }
34017 arg2 = static_cast< int >(val2);
34018 }
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34022 wxPyEndAllowThreads(__tstate);
34023 if (PyErr_Occurred()) SWIG_fail;
34024 }
34025 resultobj = SWIG_From_int(static_cast< int >(result));
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34033 PyObject *resultobj = 0;
34034 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34035 wxDragResult arg2 ;
34036 bool result;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 int val2 ;
34040 int ecode2 = 0 ;
34041 PyObject * obj0 = 0 ;
34042 PyObject * obj1 = 0 ;
34043 char * kwnames[] = {
34044 (char *) "self",(char *) "effect", NULL
34045 };
34046
34047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34049 if (!SWIG_IsOK(res1)) {
34050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34051 }
34052 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34053 ecode2 = SWIG_AsVal_int(obj1, &val2);
34054 if (!SWIG_IsOK(ecode2)) {
34055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34056 }
34057 arg2 = static_cast< wxDragResult >(val2);
34058 {
34059 PyThreadState* __tstate = wxPyBeginAllowThreads();
34060 result = (bool)(arg1)->GiveFeedback(arg2);
34061 wxPyEndAllowThreads(__tstate);
34062 if (PyErr_Occurred()) SWIG_fail;
34063 }
34064 {
34065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34066 }
34067 return resultobj;
34068 fail:
34069 return NULL;
34070 }
34071
34072
34073 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34074 PyObject *obj;
34075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34076 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34077 return SWIG_Py_Void();
34078 }
34079
34080 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34081 return SWIG_Python_InitShadowInstance(args);
34082 }
34083
34084 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34085 PyObject *resultobj = 0;
34086 wxDataObject *arg1 = (wxDataObject *) NULL ;
34087 wxPyDropTarget *result = 0 ;
34088 int res1 = 0 ;
34089 PyObject * obj0 = 0 ;
34090 char * kwnames[] = {
34091 (char *) "dataObject", NULL
34092 };
34093
34094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34095 if (obj0) {
34096 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34097 if (!SWIG_IsOK(res1)) {
34098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34099 }
34100 }
34101 {
34102 PyThreadState* __tstate = wxPyBeginAllowThreads();
34103 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34104 wxPyEndAllowThreads(__tstate);
34105 if (PyErr_Occurred()) SWIG_fail;
34106 }
34107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34108 return resultobj;
34109 fail:
34110 return NULL;
34111 }
34112
34113
34114 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34115 PyObject *resultobj = 0;
34116 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34117 PyObject *arg2 = (PyObject *) 0 ;
34118 PyObject *arg3 = (PyObject *) 0 ;
34119 void *argp1 = 0 ;
34120 int res1 = 0 ;
34121 PyObject * obj0 = 0 ;
34122 PyObject * obj1 = 0 ;
34123 PyObject * obj2 = 0 ;
34124 char * kwnames[] = {
34125 (char *) "self",(char *) "self",(char *) "_class", NULL
34126 };
34127
34128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34130 if (!SWIG_IsOK(res1)) {
34131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34132 }
34133 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34134 arg2 = obj1;
34135 arg3 = obj2;
34136 {
34137 PyThreadState* __tstate = wxPyBeginAllowThreads();
34138 (arg1)->_setCallbackInfo(arg2,arg3);
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 resultobj = SWIG_Py_Void();
34143 return resultobj;
34144 fail:
34145 return NULL;
34146 }
34147
34148
34149 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34150 PyObject *resultobj = 0;
34151 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34152 void *argp1 = 0 ;
34153 int res1 = 0 ;
34154 PyObject *swig_obj[1] ;
34155
34156 if (!args) SWIG_fail;
34157 swig_obj[0] = args;
34158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34159 if (!SWIG_IsOK(res1)) {
34160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34161 }
34162 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34163 {
34164 PyThreadState* __tstate = wxPyBeginAllowThreads();
34165 delete arg1;
34166
34167 wxPyEndAllowThreads(__tstate);
34168 if (PyErr_Occurred()) SWIG_fail;
34169 }
34170 resultobj = SWIG_Py_Void();
34171 return resultobj;
34172 fail:
34173 return NULL;
34174 }
34175
34176
34177 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34178 PyObject *resultobj = 0;
34179 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34180 wxDataObject *result = 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, 0 | 0 );
34188 if (!SWIG_IsOK(res1)) {
34189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34190 }
34191 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34192 {
34193 PyThreadState* __tstate = wxPyBeginAllowThreads();
34194 result = (wxDataObject *)(arg1)->GetDataObject();
34195 wxPyEndAllowThreads(__tstate);
34196 if (PyErr_Occurred()) SWIG_fail;
34197 }
34198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34199 return resultobj;
34200 fail:
34201 return NULL;
34202 }
34203
34204
34205 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34206 PyObject *resultobj = 0;
34207 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34208 wxDataObject *arg2 = (wxDataObject *) 0 ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 int res2 = 0 ;
34212 PyObject * obj0 = 0 ;
34213 PyObject * obj1 = 0 ;
34214 char * kwnames[] = {
34215 (char *) "self",(char *) "dataObject", NULL
34216 };
34217
34218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34220 if (!SWIG_IsOK(res1)) {
34221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34222 }
34223 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34224 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34225 if (!SWIG_IsOK(res2)) {
34226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34227 }
34228 {
34229 PyThreadState* __tstate = wxPyBeginAllowThreads();
34230 (arg1)->SetDataObject(arg2);
34231 wxPyEndAllowThreads(__tstate);
34232 if (PyErr_Occurred()) SWIG_fail;
34233 }
34234 resultobj = SWIG_Py_Void();
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34242 PyObject *resultobj = 0;
34243 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34244 int arg2 ;
34245 int arg3 ;
34246 wxDragResult arg4 ;
34247 wxDragResult result;
34248 void *argp1 = 0 ;
34249 int res1 = 0 ;
34250 int val2 ;
34251 int ecode2 = 0 ;
34252 int val3 ;
34253 int ecode3 = 0 ;
34254 int val4 ;
34255 int ecode4 = 0 ;
34256 PyObject * obj0 = 0 ;
34257 PyObject * obj1 = 0 ;
34258 PyObject * obj2 = 0 ;
34259 PyObject * obj3 = 0 ;
34260 char * kwnames[] = {
34261 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34262 };
34263
34264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34266 if (!SWIG_IsOK(res1)) {
34267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34268 }
34269 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34270 ecode2 = SWIG_AsVal_int(obj1, &val2);
34271 if (!SWIG_IsOK(ecode2)) {
34272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34273 }
34274 arg2 = static_cast< int >(val2);
34275 ecode3 = SWIG_AsVal_int(obj2, &val3);
34276 if (!SWIG_IsOK(ecode3)) {
34277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34278 }
34279 arg3 = static_cast< int >(val3);
34280 ecode4 = SWIG_AsVal_int(obj3, &val4);
34281 if (!SWIG_IsOK(ecode4)) {
34282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34283 }
34284 arg4 = static_cast< wxDragResult >(val4);
34285 {
34286 PyThreadState* __tstate = wxPyBeginAllowThreads();
34287 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34288 wxPyEndAllowThreads(__tstate);
34289 if (PyErr_Occurred()) SWIG_fail;
34290 }
34291 resultobj = SWIG_From_int(static_cast< int >(result));
34292 return resultobj;
34293 fail:
34294 return NULL;
34295 }
34296
34297
34298 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34299 PyObject *resultobj = 0;
34300 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34301 int arg2 ;
34302 int arg3 ;
34303 wxDragResult arg4 ;
34304 wxDragResult result;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 int val2 ;
34308 int ecode2 = 0 ;
34309 int val3 ;
34310 int ecode3 = 0 ;
34311 int val4 ;
34312 int ecode4 = 0 ;
34313 PyObject * obj0 = 0 ;
34314 PyObject * obj1 = 0 ;
34315 PyObject * obj2 = 0 ;
34316 PyObject * obj3 = 0 ;
34317 char * kwnames[] = {
34318 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34319 };
34320
34321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34323 if (!SWIG_IsOK(res1)) {
34324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34325 }
34326 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34327 ecode2 = SWIG_AsVal_int(obj1, &val2);
34328 if (!SWIG_IsOK(ecode2)) {
34329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34330 }
34331 arg2 = static_cast< int >(val2);
34332 ecode3 = SWIG_AsVal_int(obj2, &val3);
34333 if (!SWIG_IsOK(ecode3)) {
34334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34335 }
34336 arg3 = static_cast< int >(val3);
34337 ecode4 = SWIG_AsVal_int(obj3, &val4);
34338 if (!SWIG_IsOK(ecode4)) {
34339 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34340 }
34341 arg4 = static_cast< wxDragResult >(val4);
34342 {
34343 PyThreadState* __tstate = wxPyBeginAllowThreads();
34344 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34345 wxPyEndAllowThreads(__tstate);
34346 if (PyErr_Occurred()) SWIG_fail;
34347 }
34348 resultobj = SWIG_From_int(static_cast< int >(result));
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34356 PyObject *resultobj = 0;
34357 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34358 void *argp1 = 0 ;
34359 int res1 = 0 ;
34360 PyObject *swig_obj[1] ;
34361
34362 if (!args) SWIG_fail;
34363 swig_obj[0] = args;
34364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34365 if (!SWIG_IsOK(res1)) {
34366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34367 }
34368 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34369 {
34370 PyThreadState* __tstate = wxPyBeginAllowThreads();
34371 (arg1)->OnLeave();
34372 wxPyEndAllowThreads(__tstate);
34373 if (PyErr_Occurred()) SWIG_fail;
34374 }
34375 resultobj = SWIG_Py_Void();
34376 return resultobj;
34377 fail:
34378 return NULL;
34379 }
34380
34381
34382 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34383 PyObject *resultobj = 0;
34384 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34385 int arg2 ;
34386 int arg3 ;
34387 bool result;
34388 void *argp1 = 0 ;
34389 int res1 = 0 ;
34390 int val2 ;
34391 int ecode2 = 0 ;
34392 int val3 ;
34393 int ecode3 = 0 ;
34394 PyObject * obj0 = 0 ;
34395 PyObject * obj1 = 0 ;
34396 PyObject * obj2 = 0 ;
34397 char * kwnames[] = {
34398 (char *) "self",(char *) "x",(char *) "y", NULL
34399 };
34400
34401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34403 if (!SWIG_IsOK(res1)) {
34404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34405 }
34406 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34407 ecode2 = SWIG_AsVal_int(obj1, &val2);
34408 if (!SWIG_IsOK(ecode2)) {
34409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34410 }
34411 arg2 = static_cast< int >(val2);
34412 ecode3 = SWIG_AsVal_int(obj2, &val3);
34413 if (!SWIG_IsOK(ecode3)) {
34414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34415 }
34416 arg3 = static_cast< int >(val3);
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 result = (bool)(arg1)->OnDrop(arg2,arg3);
34420 wxPyEndAllowThreads(__tstate);
34421 if (PyErr_Occurred()) SWIG_fail;
34422 }
34423 {
34424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34425 }
34426 return resultobj;
34427 fail:
34428 return NULL;
34429 }
34430
34431
34432 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34433 PyObject *resultobj = 0;
34434 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34435 bool result;
34436 void *argp1 = 0 ;
34437 int res1 = 0 ;
34438 PyObject *swig_obj[1] ;
34439
34440 if (!args) SWIG_fail;
34441 swig_obj[0] = args;
34442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34443 if (!SWIG_IsOK(res1)) {
34444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34445 }
34446 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34447 {
34448 PyThreadState* __tstate = wxPyBeginAllowThreads();
34449 result = (bool)(arg1)->GetData();
34450 wxPyEndAllowThreads(__tstate);
34451 if (PyErr_Occurred()) SWIG_fail;
34452 }
34453 {
34454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34455 }
34456 return resultobj;
34457 fail:
34458 return NULL;
34459 }
34460
34461
34462 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34463 PyObject *resultobj = 0;
34464 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34465 wxDragResult arg2 ;
34466 void *argp1 = 0 ;
34467 int res1 = 0 ;
34468 int val2 ;
34469 int ecode2 = 0 ;
34470 PyObject * obj0 = 0 ;
34471 PyObject * obj1 = 0 ;
34472 char * kwnames[] = {
34473 (char *) "self",(char *) "action", NULL
34474 };
34475
34476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34478 if (!SWIG_IsOK(res1)) {
34479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34480 }
34481 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34482 ecode2 = SWIG_AsVal_int(obj1, &val2);
34483 if (!SWIG_IsOK(ecode2)) {
34484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34485 }
34486 arg2 = static_cast< wxDragResult >(val2);
34487 {
34488 PyThreadState* __tstate = wxPyBeginAllowThreads();
34489 (arg1)->SetDefaultAction(arg2);
34490 wxPyEndAllowThreads(__tstate);
34491 if (PyErr_Occurred()) SWIG_fail;
34492 }
34493 resultobj = SWIG_Py_Void();
34494 return resultobj;
34495 fail:
34496 return NULL;
34497 }
34498
34499
34500 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34501 PyObject *resultobj = 0;
34502 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34503 wxDragResult result;
34504 void *argp1 = 0 ;
34505 int res1 = 0 ;
34506 PyObject *swig_obj[1] ;
34507
34508 if (!args) SWIG_fail;
34509 swig_obj[0] = args;
34510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34511 if (!SWIG_IsOK(res1)) {
34512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34513 }
34514 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34515 {
34516 PyThreadState* __tstate = wxPyBeginAllowThreads();
34517 result = (wxDragResult)(arg1)->GetDefaultAction();
34518 wxPyEndAllowThreads(__tstate);
34519 if (PyErr_Occurred()) SWIG_fail;
34520 }
34521 resultobj = SWIG_From_int(static_cast< int >(result));
34522 return resultobj;
34523 fail:
34524 return NULL;
34525 }
34526
34527
34528 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34529 PyObject *obj;
34530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34531 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34532 return SWIG_Py_Void();
34533 }
34534
34535 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34536 return SWIG_Python_InitShadowInstance(args);
34537 }
34538
34539 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34540 PyObject *resultobj = 0;
34541 wxPyTextDropTarget *result = 0 ;
34542
34543 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34551 return resultobj;
34552 fail:
34553 return NULL;
34554 }
34555
34556
34557 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34558 PyObject *resultobj = 0;
34559 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34560 PyObject *arg2 = (PyObject *) 0 ;
34561 PyObject *arg3 = (PyObject *) 0 ;
34562 void *argp1 = 0 ;
34563 int res1 = 0 ;
34564 PyObject * obj0 = 0 ;
34565 PyObject * obj1 = 0 ;
34566 PyObject * obj2 = 0 ;
34567 char * kwnames[] = {
34568 (char *) "self",(char *) "self",(char *) "_class", NULL
34569 };
34570
34571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34573 if (!SWIG_IsOK(res1)) {
34574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34575 }
34576 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34577 arg2 = obj1;
34578 arg3 = obj2;
34579 {
34580 PyThreadState* __tstate = wxPyBeginAllowThreads();
34581 (arg1)->_setCallbackInfo(arg2,arg3);
34582 wxPyEndAllowThreads(__tstate);
34583 if (PyErr_Occurred()) SWIG_fail;
34584 }
34585 resultobj = SWIG_Py_Void();
34586 return resultobj;
34587 fail:
34588 return NULL;
34589 }
34590
34591
34592 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34593 PyObject *resultobj = 0;
34594 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34595 int arg2 ;
34596 int arg3 ;
34597 wxString *arg4 = 0 ;
34598 bool result;
34599 void *argp1 = 0 ;
34600 int res1 = 0 ;
34601 int val2 ;
34602 int ecode2 = 0 ;
34603 int val3 ;
34604 int ecode3 = 0 ;
34605 bool temp4 = false ;
34606 PyObject * obj0 = 0 ;
34607 PyObject * obj1 = 0 ;
34608 PyObject * obj2 = 0 ;
34609 PyObject * obj3 = 0 ;
34610 char * kwnames[] = {
34611 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34612 };
34613
34614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34616 if (!SWIG_IsOK(res1)) {
34617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34618 }
34619 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34620 ecode2 = SWIG_AsVal_int(obj1, &val2);
34621 if (!SWIG_IsOK(ecode2)) {
34622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34623 }
34624 arg2 = static_cast< int >(val2);
34625 ecode3 = SWIG_AsVal_int(obj2, &val3);
34626 if (!SWIG_IsOK(ecode3)) {
34627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34628 }
34629 arg3 = static_cast< int >(val3);
34630 {
34631 arg4 = wxString_in_helper(obj3);
34632 if (arg4 == NULL) SWIG_fail;
34633 temp4 = true;
34634 }
34635 {
34636 PyThreadState* __tstate = wxPyBeginAllowThreads();
34637 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34638 wxPyEndAllowThreads(__tstate);
34639 if (PyErr_Occurred()) SWIG_fail;
34640 }
34641 {
34642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34643 }
34644 {
34645 if (temp4)
34646 delete arg4;
34647 }
34648 return resultobj;
34649 fail:
34650 {
34651 if (temp4)
34652 delete arg4;
34653 }
34654 return NULL;
34655 }
34656
34657
34658 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34659 PyObject *resultobj = 0;
34660 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34661 int arg2 ;
34662 int arg3 ;
34663 wxDragResult arg4 ;
34664 wxDragResult result;
34665 void *argp1 = 0 ;
34666 int res1 = 0 ;
34667 int val2 ;
34668 int ecode2 = 0 ;
34669 int val3 ;
34670 int ecode3 = 0 ;
34671 int val4 ;
34672 int ecode4 = 0 ;
34673 PyObject * obj0 = 0 ;
34674 PyObject * obj1 = 0 ;
34675 PyObject * obj2 = 0 ;
34676 PyObject * obj3 = 0 ;
34677 char * kwnames[] = {
34678 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34679 };
34680
34681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34683 if (!SWIG_IsOK(res1)) {
34684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34685 }
34686 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34687 ecode2 = SWIG_AsVal_int(obj1, &val2);
34688 if (!SWIG_IsOK(ecode2)) {
34689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34690 }
34691 arg2 = static_cast< int >(val2);
34692 ecode3 = SWIG_AsVal_int(obj2, &val3);
34693 if (!SWIG_IsOK(ecode3)) {
34694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34695 }
34696 arg3 = static_cast< int >(val3);
34697 ecode4 = SWIG_AsVal_int(obj3, &val4);
34698 if (!SWIG_IsOK(ecode4)) {
34699 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34700 }
34701 arg4 = static_cast< wxDragResult >(val4);
34702 {
34703 PyThreadState* __tstate = wxPyBeginAllowThreads();
34704 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34705 wxPyEndAllowThreads(__tstate);
34706 if (PyErr_Occurred()) SWIG_fail;
34707 }
34708 resultobj = SWIG_From_int(static_cast< int >(result));
34709 return resultobj;
34710 fail:
34711 return NULL;
34712 }
34713
34714
34715 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34716 PyObject *resultobj = 0;
34717 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34718 int arg2 ;
34719 int arg3 ;
34720 wxDragResult arg4 ;
34721 wxDragResult result;
34722 void *argp1 = 0 ;
34723 int res1 = 0 ;
34724 int val2 ;
34725 int ecode2 = 0 ;
34726 int val3 ;
34727 int ecode3 = 0 ;
34728 int val4 ;
34729 int ecode4 = 0 ;
34730 PyObject * obj0 = 0 ;
34731 PyObject * obj1 = 0 ;
34732 PyObject * obj2 = 0 ;
34733 PyObject * obj3 = 0 ;
34734 char * kwnames[] = {
34735 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34736 };
34737
34738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34740 if (!SWIG_IsOK(res1)) {
34741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34742 }
34743 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34744 ecode2 = SWIG_AsVal_int(obj1, &val2);
34745 if (!SWIG_IsOK(ecode2)) {
34746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34747 }
34748 arg2 = static_cast< int >(val2);
34749 ecode3 = SWIG_AsVal_int(obj2, &val3);
34750 if (!SWIG_IsOK(ecode3)) {
34751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34752 }
34753 arg3 = static_cast< int >(val3);
34754 ecode4 = SWIG_AsVal_int(obj3, &val4);
34755 if (!SWIG_IsOK(ecode4)) {
34756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34757 }
34758 arg4 = static_cast< wxDragResult >(val4);
34759 {
34760 PyThreadState* __tstate = wxPyBeginAllowThreads();
34761 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34762 wxPyEndAllowThreads(__tstate);
34763 if (PyErr_Occurred()) SWIG_fail;
34764 }
34765 resultobj = SWIG_From_int(static_cast< int >(result));
34766 return resultobj;
34767 fail:
34768 return NULL;
34769 }
34770
34771
34772 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34773 PyObject *resultobj = 0;
34774 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34775 void *argp1 = 0 ;
34776 int res1 = 0 ;
34777 PyObject *swig_obj[1] ;
34778
34779 if (!args) SWIG_fail;
34780 swig_obj[0] = args;
34781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34782 if (!SWIG_IsOK(res1)) {
34783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34784 }
34785 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34786 {
34787 PyThreadState* __tstate = wxPyBeginAllowThreads();
34788 (arg1)->OnLeave();
34789 wxPyEndAllowThreads(__tstate);
34790 if (PyErr_Occurred()) SWIG_fail;
34791 }
34792 resultobj = SWIG_Py_Void();
34793 return resultobj;
34794 fail:
34795 return NULL;
34796 }
34797
34798
34799 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34800 PyObject *resultobj = 0;
34801 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34802 int arg2 ;
34803 int arg3 ;
34804 bool result;
34805 void *argp1 = 0 ;
34806 int res1 = 0 ;
34807 int val2 ;
34808 int ecode2 = 0 ;
34809 int val3 ;
34810 int ecode3 = 0 ;
34811 PyObject * obj0 = 0 ;
34812 PyObject * obj1 = 0 ;
34813 PyObject * obj2 = 0 ;
34814 char * kwnames[] = {
34815 (char *) "self",(char *) "x",(char *) "y", NULL
34816 };
34817
34818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34820 if (!SWIG_IsOK(res1)) {
34821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34822 }
34823 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34824 ecode2 = SWIG_AsVal_int(obj1, &val2);
34825 if (!SWIG_IsOK(ecode2)) {
34826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34827 }
34828 arg2 = static_cast< int >(val2);
34829 ecode3 = SWIG_AsVal_int(obj2, &val3);
34830 if (!SWIG_IsOK(ecode3)) {
34831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34832 }
34833 arg3 = static_cast< int >(val3);
34834 {
34835 PyThreadState* __tstate = wxPyBeginAllowThreads();
34836 result = (bool)(arg1)->OnDrop(arg2,arg3);
34837 wxPyEndAllowThreads(__tstate);
34838 if (PyErr_Occurred()) SWIG_fail;
34839 }
34840 {
34841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34842 }
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34850 PyObject *resultobj = 0;
34851 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34852 int arg2 ;
34853 int arg3 ;
34854 wxDragResult arg4 ;
34855 wxDragResult result;
34856 void *argp1 = 0 ;
34857 int res1 = 0 ;
34858 int val2 ;
34859 int ecode2 = 0 ;
34860 int val3 ;
34861 int ecode3 = 0 ;
34862 int val4 ;
34863 int ecode4 = 0 ;
34864 PyObject * obj0 = 0 ;
34865 PyObject * obj1 = 0 ;
34866 PyObject * obj2 = 0 ;
34867 PyObject * obj3 = 0 ;
34868 char * kwnames[] = {
34869 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34870 };
34871
34872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34874 if (!SWIG_IsOK(res1)) {
34875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34876 }
34877 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34878 ecode2 = SWIG_AsVal_int(obj1, &val2);
34879 if (!SWIG_IsOK(ecode2)) {
34880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34881 }
34882 arg2 = static_cast< int >(val2);
34883 ecode3 = SWIG_AsVal_int(obj2, &val3);
34884 if (!SWIG_IsOK(ecode3)) {
34885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34886 }
34887 arg3 = static_cast< int >(val3);
34888 ecode4 = SWIG_AsVal_int(obj3, &val4);
34889 if (!SWIG_IsOK(ecode4)) {
34890 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34891 }
34892 arg4 = static_cast< wxDragResult >(val4);
34893 {
34894 PyThreadState* __tstate = wxPyBeginAllowThreads();
34895 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 resultobj = SWIG_From_int(static_cast< int >(result));
34900 return resultobj;
34901 fail:
34902 return NULL;
34903 }
34904
34905
34906 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34907 PyObject *obj;
34908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34909 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34910 return SWIG_Py_Void();
34911 }
34912
34913 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34914 return SWIG_Python_InitShadowInstance(args);
34915 }
34916
34917 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34918 PyObject *resultobj = 0;
34919 wxPyFileDropTarget *result = 0 ;
34920
34921 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34922 {
34923 PyThreadState* __tstate = wxPyBeginAllowThreads();
34924 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34925 wxPyEndAllowThreads(__tstate);
34926 if (PyErr_Occurred()) SWIG_fail;
34927 }
34928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34929 return resultobj;
34930 fail:
34931 return NULL;
34932 }
34933
34934
34935 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34936 PyObject *resultobj = 0;
34937 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34938 PyObject *arg2 = (PyObject *) 0 ;
34939 PyObject *arg3 = (PyObject *) 0 ;
34940 void *argp1 = 0 ;
34941 int res1 = 0 ;
34942 PyObject * obj0 = 0 ;
34943 PyObject * obj1 = 0 ;
34944 PyObject * obj2 = 0 ;
34945 char * kwnames[] = {
34946 (char *) "self",(char *) "self",(char *) "_class", NULL
34947 };
34948
34949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34951 if (!SWIG_IsOK(res1)) {
34952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34953 }
34954 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34955 arg2 = obj1;
34956 arg3 = obj2;
34957 {
34958 PyThreadState* __tstate = wxPyBeginAllowThreads();
34959 (arg1)->_setCallbackInfo(arg2,arg3);
34960 wxPyEndAllowThreads(__tstate);
34961 if (PyErr_Occurred()) SWIG_fail;
34962 }
34963 resultobj = SWIG_Py_Void();
34964 return resultobj;
34965 fail:
34966 return NULL;
34967 }
34968
34969
34970 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34971 PyObject *resultobj = 0;
34972 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34973 int arg2 ;
34974 int arg3 ;
34975 wxArrayString *arg4 = 0 ;
34976 bool result;
34977 void *argp1 = 0 ;
34978 int res1 = 0 ;
34979 int val2 ;
34980 int ecode2 = 0 ;
34981 int val3 ;
34982 int ecode3 = 0 ;
34983 bool temp4 = false ;
34984 PyObject * obj0 = 0 ;
34985 PyObject * obj1 = 0 ;
34986 PyObject * obj2 = 0 ;
34987 PyObject * obj3 = 0 ;
34988 char * kwnames[] = {
34989 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34990 };
34991
34992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34994 if (!SWIG_IsOK(res1)) {
34995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34996 }
34997 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34998 ecode2 = SWIG_AsVal_int(obj1, &val2);
34999 if (!SWIG_IsOK(ecode2)) {
35000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
35001 }
35002 arg2 = static_cast< int >(val2);
35003 ecode3 = SWIG_AsVal_int(obj2, &val3);
35004 if (!SWIG_IsOK(ecode3)) {
35005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
35006 }
35007 arg3 = static_cast< int >(val3);
35008 {
35009 if (! PySequence_Check(obj3)) {
35010 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
35011 SWIG_fail;
35012 }
35013 arg4 = new wxArrayString;
35014 temp4 = true;
35015 int i, len=PySequence_Length(obj3);
35016 for (i=0; i<len; i++) {
35017 PyObject* item = PySequence_GetItem(obj3, i);
35018 wxString* s = wxString_in_helper(item);
35019 if (PyErr_Occurred()) SWIG_fail;
35020 arg4->Add(*s);
35021 delete s;
35022 Py_DECREF(item);
35023 }
35024 }
35025 {
35026 PyThreadState* __tstate = wxPyBeginAllowThreads();
35027 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35028 wxPyEndAllowThreads(__tstate);
35029 if (PyErr_Occurred()) SWIG_fail;
35030 }
35031 {
35032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35033 }
35034 {
35035 if (temp4) delete arg4;
35036 }
35037 return resultobj;
35038 fail:
35039 {
35040 if (temp4) delete arg4;
35041 }
35042 return NULL;
35043 }
35044
35045
35046 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35047 PyObject *resultobj = 0;
35048 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35049 int arg2 ;
35050 int arg3 ;
35051 wxDragResult arg4 ;
35052 wxDragResult result;
35053 void *argp1 = 0 ;
35054 int res1 = 0 ;
35055 int val2 ;
35056 int ecode2 = 0 ;
35057 int val3 ;
35058 int ecode3 = 0 ;
35059 int val4 ;
35060 int ecode4 = 0 ;
35061 PyObject * obj0 = 0 ;
35062 PyObject * obj1 = 0 ;
35063 PyObject * obj2 = 0 ;
35064 PyObject * obj3 = 0 ;
35065 char * kwnames[] = {
35066 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35067 };
35068
35069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35071 if (!SWIG_IsOK(res1)) {
35072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35073 }
35074 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35075 ecode2 = SWIG_AsVal_int(obj1, &val2);
35076 if (!SWIG_IsOK(ecode2)) {
35077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35078 }
35079 arg2 = static_cast< int >(val2);
35080 ecode3 = SWIG_AsVal_int(obj2, &val3);
35081 if (!SWIG_IsOK(ecode3)) {
35082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35083 }
35084 arg3 = static_cast< int >(val3);
35085 ecode4 = SWIG_AsVal_int(obj3, &val4);
35086 if (!SWIG_IsOK(ecode4)) {
35087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35088 }
35089 arg4 = static_cast< wxDragResult >(val4);
35090 {
35091 PyThreadState* __tstate = wxPyBeginAllowThreads();
35092 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35093 wxPyEndAllowThreads(__tstate);
35094 if (PyErr_Occurred()) SWIG_fail;
35095 }
35096 resultobj = SWIG_From_int(static_cast< int >(result));
35097 return resultobj;
35098 fail:
35099 return NULL;
35100 }
35101
35102
35103 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35104 PyObject *resultobj = 0;
35105 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35106 int arg2 ;
35107 int arg3 ;
35108 wxDragResult arg4 ;
35109 wxDragResult result;
35110 void *argp1 = 0 ;
35111 int res1 = 0 ;
35112 int val2 ;
35113 int ecode2 = 0 ;
35114 int val3 ;
35115 int ecode3 = 0 ;
35116 int val4 ;
35117 int ecode4 = 0 ;
35118 PyObject * obj0 = 0 ;
35119 PyObject * obj1 = 0 ;
35120 PyObject * obj2 = 0 ;
35121 PyObject * obj3 = 0 ;
35122 char * kwnames[] = {
35123 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35124 };
35125
35126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35128 if (!SWIG_IsOK(res1)) {
35129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35130 }
35131 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35132 ecode2 = SWIG_AsVal_int(obj1, &val2);
35133 if (!SWIG_IsOK(ecode2)) {
35134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35135 }
35136 arg2 = static_cast< int >(val2);
35137 ecode3 = SWIG_AsVal_int(obj2, &val3);
35138 if (!SWIG_IsOK(ecode3)) {
35139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35140 }
35141 arg3 = static_cast< int >(val3);
35142 ecode4 = SWIG_AsVal_int(obj3, &val4);
35143 if (!SWIG_IsOK(ecode4)) {
35144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35145 }
35146 arg4 = static_cast< wxDragResult >(val4);
35147 {
35148 PyThreadState* __tstate = wxPyBeginAllowThreads();
35149 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35150 wxPyEndAllowThreads(__tstate);
35151 if (PyErr_Occurred()) SWIG_fail;
35152 }
35153 resultobj = SWIG_From_int(static_cast< int >(result));
35154 return resultobj;
35155 fail:
35156 return NULL;
35157 }
35158
35159
35160 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35161 PyObject *resultobj = 0;
35162 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35163 void *argp1 = 0 ;
35164 int res1 = 0 ;
35165 PyObject *swig_obj[1] ;
35166
35167 if (!args) SWIG_fail;
35168 swig_obj[0] = args;
35169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35170 if (!SWIG_IsOK(res1)) {
35171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35172 }
35173 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35174 {
35175 PyThreadState* __tstate = wxPyBeginAllowThreads();
35176 (arg1)->OnLeave();
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 resultobj = SWIG_Py_Void();
35181 return resultobj;
35182 fail:
35183 return NULL;
35184 }
35185
35186
35187 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35188 PyObject *resultobj = 0;
35189 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35190 int arg2 ;
35191 int arg3 ;
35192 bool result;
35193 void *argp1 = 0 ;
35194 int res1 = 0 ;
35195 int val2 ;
35196 int ecode2 = 0 ;
35197 int val3 ;
35198 int ecode3 = 0 ;
35199 PyObject * obj0 = 0 ;
35200 PyObject * obj1 = 0 ;
35201 PyObject * obj2 = 0 ;
35202 char * kwnames[] = {
35203 (char *) "self",(char *) "x",(char *) "y", NULL
35204 };
35205
35206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35208 if (!SWIG_IsOK(res1)) {
35209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35210 }
35211 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35212 ecode2 = SWIG_AsVal_int(obj1, &val2);
35213 if (!SWIG_IsOK(ecode2)) {
35214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35215 }
35216 arg2 = static_cast< int >(val2);
35217 ecode3 = SWIG_AsVal_int(obj2, &val3);
35218 if (!SWIG_IsOK(ecode3)) {
35219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35220 }
35221 arg3 = static_cast< int >(val3);
35222 {
35223 PyThreadState* __tstate = wxPyBeginAllowThreads();
35224 result = (bool)(arg1)->OnDrop(arg2,arg3);
35225 wxPyEndAllowThreads(__tstate);
35226 if (PyErr_Occurred()) SWIG_fail;
35227 }
35228 {
35229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35230 }
35231 return resultobj;
35232 fail:
35233 return NULL;
35234 }
35235
35236
35237 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35238 PyObject *resultobj = 0;
35239 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35240 int arg2 ;
35241 int arg3 ;
35242 wxDragResult arg4 ;
35243 wxDragResult result;
35244 void *argp1 = 0 ;
35245 int res1 = 0 ;
35246 int val2 ;
35247 int ecode2 = 0 ;
35248 int val3 ;
35249 int ecode3 = 0 ;
35250 int val4 ;
35251 int ecode4 = 0 ;
35252 PyObject * obj0 = 0 ;
35253 PyObject * obj1 = 0 ;
35254 PyObject * obj2 = 0 ;
35255 PyObject * obj3 = 0 ;
35256 char * kwnames[] = {
35257 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35258 };
35259
35260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35262 if (!SWIG_IsOK(res1)) {
35263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35264 }
35265 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35266 ecode2 = SWIG_AsVal_int(obj1, &val2);
35267 if (!SWIG_IsOK(ecode2)) {
35268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35269 }
35270 arg2 = static_cast< int >(val2);
35271 ecode3 = SWIG_AsVal_int(obj2, &val3);
35272 if (!SWIG_IsOK(ecode3)) {
35273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35274 }
35275 arg3 = static_cast< int >(val3);
35276 ecode4 = SWIG_AsVal_int(obj3, &val4);
35277 if (!SWIG_IsOK(ecode4)) {
35278 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35279 }
35280 arg4 = static_cast< wxDragResult >(val4);
35281 {
35282 PyThreadState* __tstate = wxPyBeginAllowThreads();
35283 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35284 wxPyEndAllowThreads(__tstate);
35285 if (PyErr_Occurred()) SWIG_fail;
35286 }
35287 resultobj = SWIG_From_int(static_cast< int >(result));
35288 return resultobj;
35289 fail:
35290 return NULL;
35291 }
35292
35293
35294 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35295 PyObject *obj;
35296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35297 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35298 return SWIG_Py_Void();
35299 }
35300
35301 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35302 return SWIG_Python_InitShadowInstance(args);
35303 }
35304
35305 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35306 PyObject *resultobj = 0;
35307 wxClipboard *result = 0 ;
35308
35309 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35310 {
35311 PyThreadState* __tstate = wxPyBeginAllowThreads();
35312 result = (wxClipboard *)new wxClipboard();
35313 wxPyEndAllowThreads(__tstate);
35314 if (PyErr_Occurred()) SWIG_fail;
35315 }
35316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35317 return resultobj;
35318 fail:
35319 return NULL;
35320 }
35321
35322
35323 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35324 PyObject *resultobj = 0;
35325 wxClipboard *arg1 = (wxClipboard *) 0 ;
35326 void *argp1 = 0 ;
35327 int res1 = 0 ;
35328 PyObject *swig_obj[1] ;
35329
35330 if (!args) SWIG_fail;
35331 swig_obj[0] = args;
35332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35333 if (!SWIG_IsOK(res1)) {
35334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35335 }
35336 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35337 {
35338 PyThreadState* __tstate = wxPyBeginAllowThreads();
35339 delete arg1;
35340
35341 wxPyEndAllowThreads(__tstate);
35342 if (PyErr_Occurred()) SWIG_fail;
35343 }
35344 resultobj = SWIG_Py_Void();
35345 return resultobj;
35346 fail:
35347 return NULL;
35348 }
35349
35350
35351 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35352 PyObject *resultobj = 0;
35353 wxClipboard *arg1 = (wxClipboard *) 0 ;
35354 bool result;
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, 0 | 0 );
35362 if (!SWIG_IsOK(res1)) {
35363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35364 }
35365 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 result = (bool)(arg1)->Open();
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 {
35373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35374 }
35375 return resultobj;
35376 fail:
35377 return NULL;
35378 }
35379
35380
35381 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35382 PyObject *resultobj = 0;
35383 wxClipboard *arg1 = (wxClipboard *) 0 ;
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_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35393 }
35394 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35395 {
35396 PyThreadState* __tstate = wxPyBeginAllowThreads();
35397 (arg1)->Close();
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 resultobj = SWIG_Py_Void();
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35409 PyObject *resultobj = 0;
35410 wxClipboard *arg1 = (wxClipboard *) 0 ;
35411 bool result;
35412 void *argp1 = 0 ;
35413 int res1 = 0 ;
35414 PyObject *swig_obj[1] ;
35415
35416 if (!args) SWIG_fail;
35417 swig_obj[0] = args;
35418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35421 }
35422 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 {
35430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35431 }
35432 return resultobj;
35433 fail:
35434 return NULL;
35435 }
35436
35437
35438 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35439 PyObject *resultobj = 0;
35440 wxClipboard *arg1 = (wxClipboard *) 0 ;
35441 wxDataObject *arg2 = (wxDataObject *) 0 ;
35442 bool result;
35443 void *argp1 = 0 ;
35444 int res1 = 0 ;
35445 int res2 = 0 ;
35446 PyObject * obj0 = 0 ;
35447 PyObject * obj1 = 0 ;
35448 char * kwnames[] = {
35449 (char *) "self",(char *) "data", NULL
35450 };
35451
35452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35454 if (!SWIG_IsOK(res1)) {
35455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35456 }
35457 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35458 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35459 if (!SWIG_IsOK(res2)) {
35460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35461 }
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 result = (bool)(arg1)->AddData(arg2);
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 {
35469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35470 }
35471 return resultobj;
35472 fail:
35473 return NULL;
35474 }
35475
35476
35477 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35478 PyObject *resultobj = 0;
35479 wxClipboard *arg1 = (wxClipboard *) 0 ;
35480 wxDataObject *arg2 = (wxDataObject *) 0 ;
35481 bool result;
35482 void *argp1 = 0 ;
35483 int res1 = 0 ;
35484 int res2 = 0 ;
35485 PyObject * obj0 = 0 ;
35486 PyObject * obj1 = 0 ;
35487 char * kwnames[] = {
35488 (char *) "self",(char *) "data", NULL
35489 };
35490
35491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35493 if (!SWIG_IsOK(res1)) {
35494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35495 }
35496 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35497 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35498 if (!SWIG_IsOK(res2)) {
35499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35500 }
35501 {
35502 PyThreadState* __tstate = wxPyBeginAllowThreads();
35503 result = (bool)(arg1)->SetData(arg2);
35504 wxPyEndAllowThreads(__tstate);
35505 if (PyErr_Occurred()) SWIG_fail;
35506 }
35507 {
35508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35509 }
35510 return resultobj;
35511 fail:
35512 return NULL;
35513 }
35514
35515
35516 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35517 PyObject *resultobj = 0;
35518 wxClipboard *arg1 = (wxClipboard *) 0 ;
35519 wxDataFormat *arg2 = 0 ;
35520 bool result;
35521 void *argp1 = 0 ;
35522 int res1 = 0 ;
35523 void *argp2 = 0 ;
35524 int res2 = 0 ;
35525 PyObject * obj0 = 0 ;
35526 PyObject * obj1 = 0 ;
35527 char * kwnames[] = {
35528 (char *) "self",(char *) "format", NULL
35529 };
35530
35531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35533 if (!SWIG_IsOK(res1)) {
35534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35535 }
35536 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35538 if (!SWIG_IsOK(res2)) {
35539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35540 }
35541 if (!argp2) {
35542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35543 }
35544 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 {
35552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35553 }
35554 return resultobj;
35555 fail:
35556 return NULL;
35557 }
35558
35559
35560 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35561 PyObject *resultobj = 0;
35562 wxClipboard *arg1 = (wxClipboard *) 0 ;
35563 wxDataObject *arg2 = 0 ;
35564 bool result;
35565 void *argp1 = 0 ;
35566 int res1 = 0 ;
35567 void *argp2 = 0 ;
35568 int res2 = 0 ;
35569 PyObject * obj0 = 0 ;
35570 PyObject * obj1 = 0 ;
35571 char * kwnames[] = {
35572 (char *) "self",(char *) "data", NULL
35573 };
35574
35575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35577 if (!SWIG_IsOK(res1)) {
35578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35579 }
35580 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35582 if (!SWIG_IsOK(res2)) {
35583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35584 }
35585 if (!argp2) {
35586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35587 }
35588 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35589 {
35590 PyThreadState* __tstate = wxPyBeginAllowThreads();
35591 result = (bool)(arg1)->GetData(*arg2);
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 {
35596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35597 }
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35605 PyObject *resultobj = 0;
35606 wxClipboard *arg1 = (wxClipboard *) 0 ;
35607 void *argp1 = 0 ;
35608 int res1 = 0 ;
35609 PyObject *swig_obj[1] ;
35610
35611 if (!args) SWIG_fail;
35612 swig_obj[0] = args;
35613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35614 if (!SWIG_IsOK(res1)) {
35615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35616 }
35617 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35618 {
35619 PyThreadState* __tstate = wxPyBeginAllowThreads();
35620 (arg1)->Clear();
35621 wxPyEndAllowThreads(__tstate);
35622 if (PyErr_Occurred()) SWIG_fail;
35623 }
35624 resultobj = SWIG_Py_Void();
35625 return resultobj;
35626 fail:
35627 return NULL;
35628 }
35629
35630
35631 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35632 PyObject *resultobj = 0;
35633 wxClipboard *arg1 = (wxClipboard *) 0 ;
35634 bool result;
35635 void *argp1 = 0 ;
35636 int res1 = 0 ;
35637 PyObject *swig_obj[1] ;
35638
35639 if (!args) SWIG_fail;
35640 swig_obj[0] = args;
35641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35642 if (!SWIG_IsOK(res1)) {
35643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35644 }
35645 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35646 {
35647 PyThreadState* __tstate = wxPyBeginAllowThreads();
35648 result = (bool)(arg1)->Flush();
35649 wxPyEndAllowThreads(__tstate);
35650 if (PyErr_Occurred()) SWIG_fail;
35651 }
35652 {
35653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35654 }
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35662 PyObject *resultobj = 0;
35663 wxClipboard *arg1 = (wxClipboard *) 0 ;
35664 bool arg2 = (bool) true ;
35665 void *argp1 = 0 ;
35666 int res1 = 0 ;
35667 bool val2 ;
35668 int ecode2 = 0 ;
35669 PyObject * obj0 = 0 ;
35670 PyObject * obj1 = 0 ;
35671 char * kwnames[] = {
35672 (char *) "self",(char *) "primary", NULL
35673 };
35674
35675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35677 if (!SWIG_IsOK(res1)) {
35678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35679 }
35680 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35681 if (obj1) {
35682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35683 if (!SWIG_IsOK(ecode2)) {
35684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35685 }
35686 arg2 = static_cast< bool >(val2);
35687 }
35688 {
35689 PyThreadState* __tstate = wxPyBeginAllowThreads();
35690 (arg1)->UsePrimarySelection(arg2);
35691 wxPyEndAllowThreads(__tstate);
35692 if (PyErr_Occurred()) SWIG_fail;
35693 }
35694 resultobj = SWIG_Py_Void();
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35702 PyObject *resultobj = 0;
35703 wxClipboard *result = 0 ;
35704
35705 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35706 {
35707 PyThreadState* __tstate = wxPyBeginAllowThreads();
35708 result = (wxClipboard *)wxClipboard::Get();
35709 wxPyEndAllowThreads(__tstate);
35710 if (PyErr_Occurred()) SWIG_fail;
35711 }
35712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35713 return resultobj;
35714 fail:
35715 return NULL;
35716 }
35717
35718
35719 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35720 PyObject *obj;
35721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35722 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35723 return SWIG_Py_Void();
35724 }
35725
35726 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35727 return SWIG_Python_InitShadowInstance(args);
35728 }
35729
35730 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35731 PyObject *resultobj = 0;
35732 wxClipboard *arg1 = (wxClipboard *) NULL ;
35733 wxClipboardLocker *result = 0 ;
35734 void *argp1 = 0 ;
35735 int res1 = 0 ;
35736 PyObject * obj0 = 0 ;
35737 char * kwnames[] = {
35738 (char *) "clipboard", NULL
35739 };
35740
35741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35742 if (obj0) {
35743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35744 if (!SWIG_IsOK(res1)) {
35745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35746 }
35747 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35748 }
35749 {
35750 PyThreadState* __tstate = wxPyBeginAllowThreads();
35751 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35752 wxPyEndAllowThreads(__tstate);
35753 if (PyErr_Occurred()) SWIG_fail;
35754 }
35755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35756 return resultobj;
35757 fail:
35758 return NULL;
35759 }
35760
35761
35762 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35763 PyObject *resultobj = 0;
35764 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35765 void *argp1 = 0 ;
35766 int res1 = 0 ;
35767 PyObject *swig_obj[1] ;
35768
35769 if (!args) SWIG_fail;
35770 swig_obj[0] = args;
35771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35772 if (!SWIG_IsOK(res1)) {
35773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35774 }
35775 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35776 {
35777 PyThreadState* __tstate = wxPyBeginAllowThreads();
35778 delete arg1;
35779
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 resultobj = SWIG_Py_Void();
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35791 PyObject *resultobj = 0;
35792 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35793 bool result;
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, 0 | 0 );
35801 if (!SWIG_IsOK(res1)) {
35802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35803 }
35804 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 result = (bool)wxClipboardLocker___nonzero__(arg1);
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 {
35812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35813 }
35814 return resultobj;
35815 fail:
35816 return NULL;
35817 }
35818
35819
35820 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35821 PyObject *obj;
35822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35823 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35824 return SWIG_Py_Void();
35825 }
35826
35827 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35828 return SWIG_Python_InitShadowInstance(args);
35829 }
35830
35831 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35832 PyObject *resultobj = 0;
35833 int arg1 = (int) 0 ;
35834 int arg2 = (int) 0 ;
35835 int arg3 = (int) 0 ;
35836 int arg4 = (int) 0 ;
35837 wxVideoMode *result = 0 ;
35838 int val1 ;
35839 int ecode1 = 0 ;
35840 int val2 ;
35841 int ecode2 = 0 ;
35842 int val3 ;
35843 int ecode3 = 0 ;
35844 int val4 ;
35845 int ecode4 = 0 ;
35846 PyObject * obj0 = 0 ;
35847 PyObject * obj1 = 0 ;
35848 PyObject * obj2 = 0 ;
35849 PyObject * obj3 = 0 ;
35850 char * kwnames[] = {
35851 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35852 };
35853
35854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35855 if (obj0) {
35856 ecode1 = SWIG_AsVal_int(obj0, &val1);
35857 if (!SWIG_IsOK(ecode1)) {
35858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35859 }
35860 arg1 = static_cast< int >(val1);
35861 }
35862 if (obj1) {
35863 ecode2 = SWIG_AsVal_int(obj1, &val2);
35864 if (!SWIG_IsOK(ecode2)) {
35865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35866 }
35867 arg2 = static_cast< int >(val2);
35868 }
35869 if (obj2) {
35870 ecode3 = SWIG_AsVal_int(obj2, &val3);
35871 if (!SWIG_IsOK(ecode3)) {
35872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35873 }
35874 arg3 = static_cast< int >(val3);
35875 }
35876 if (obj3) {
35877 ecode4 = SWIG_AsVal_int(obj3, &val4);
35878 if (!SWIG_IsOK(ecode4)) {
35879 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35880 }
35881 arg4 = static_cast< int >(val4);
35882 }
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35886 wxPyEndAllowThreads(__tstate);
35887 if (PyErr_Occurred()) SWIG_fail;
35888 }
35889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35890 return resultobj;
35891 fail:
35892 return NULL;
35893 }
35894
35895
35896 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35897 PyObject *resultobj = 0;
35898 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35899 void *argp1 = 0 ;
35900 int res1 = 0 ;
35901 PyObject *swig_obj[1] ;
35902
35903 if (!args) SWIG_fail;
35904 swig_obj[0] = args;
35905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35906 if (!SWIG_IsOK(res1)) {
35907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35908 }
35909 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35910 {
35911 PyThreadState* __tstate = wxPyBeginAllowThreads();
35912 delete arg1;
35913
35914 wxPyEndAllowThreads(__tstate);
35915 if (PyErr_Occurred()) SWIG_fail;
35916 }
35917 resultobj = SWIG_Py_Void();
35918 return resultobj;
35919 fail:
35920 return NULL;
35921 }
35922
35923
35924 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35925 PyObject *resultobj = 0;
35926 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35927 wxVideoMode *arg2 = 0 ;
35928 bool result;
35929 void *argp1 = 0 ;
35930 int res1 = 0 ;
35931 void *argp2 = 0 ;
35932 int res2 = 0 ;
35933 PyObject * obj0 = 0 ;
35934 PyObject * obj1 = 0 ;
35935 char * kwnames[] = {
35936 (char *) "self",(char *) "other", NULL
35937 };
35938
35939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35941 if (!SWIG_IsOK(res1)) {
35942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35943 }
35944 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35946 if (!SWIG_IsOK(res2)) {
35947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35948 }
35949 if (!argp2) {
35950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35951 }
35952 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35953 {
35954 PyThreadState* __tstate = wxPyBeginAllowThreads();
35955 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35956 wxPyEndAllowThreads(__tstate);
35957 if (PyErr_Occurred()) SWIG_fail;
35958 }
35959 {
35960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35961 }
35962 return resultobj;
35963 fail:
35964 return NULL;
35965 }
35966
35967
35968 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35969 PyObject *resultobj = 0;
35970 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35971 int result;
35972 void *argp1 = 0 ;
35973 int res1 = 0 ;
35974 PyObject *swig_obj[1] ;
35975
35976 if (!args) SWIG_fail;
35977 swig_obj[0] = args;
35978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35979 if (!SWIG_IsOK(res1)) {
35980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35981 }
35982 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 resultobj = SWIG_From_int(static_cast< int >(result));
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35997 PyObject *resultobj = 0;
35998 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35999 int result;
36000 void *argp1 = 0 ;
36001 int res1 = 0 ;
36002 PyObject *swig_obj[1] ;
36003
36004 if (!args) SWIG_fail;
36005 swig_obj[0] = args;
36006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36007 if (!SWIG_IsOK(res1)) {
36008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36009 }
36010 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36011 {
36012 PyThreadState* __tstate = wxPyBeginAllowThreads();
36013 result = (int)((wxVideoMode const *)arg1)->GetHeight();
36014 wxPyEndAllowThreads(__tstate);
36015 if (PyErr_Occurred()) SWIG_fail;
36016 }
36017 resultobj = SWIG_From_int(static_cast< int >(result));
36018 return resultobj;
36019 fail:
36020 return NULL;
36021 }
36022
36023
36024 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36025 PyObject *resultobj = 0;
36026 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36027 int result;
36028 void *argp1 = 0 ;
36029 int res1 = 0 ;
36030 PyObject *swig_obj[1] ;
36031
36032 if (!args) SWIG_fail;
36033 swig_obj[0] = args;
36034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36035 if (!SWIG_IsOK(res1)) {
36036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36037 }
36038 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36039 {
36040 PyThreadState* __tstate = wxPyBeginAllowThreads();
36041 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36042 wxPyEndAllowThreads(__tstate);
36043 if (PyErr_Occurred()) SWIG_fail;
36044 }
36045 resultobj = SWIG_From_int(static_cast< int >(result));
36046 return resultobj;
36047 fail:
36048 return NULL;
36049 }
36050
36051
36052 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36053 PyObject *resultobj = 0;
36054 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36055 bool result;
36056 void *argp1 = 0 ;
36057 int res1 = 0 ;
36058 PyObject *swig_obj[1] ;
36059
36060 if (!args) SWIG_fail;
36061 swig_obj[0] = args;
36062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36063 if (!SWIG_IsOK(res1)) {
36064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36065 }
36066 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36070 wxPyEndAllowThreads(__tstate);
36071 if (PyErr_Occurred()) SWIG_fail;
36072 }
36073 {
36074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36075 }
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36083 PyObject *resultobj = 0;
36084 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36085 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36086 bool result;
36087 void *argp1 = 0 ;
36088 int res1 = 0 ;
36089 void *argp2 = 0 ;
36090 int res2 = 0 ;
36091 PyObject * obj0 = 0 ;
36092 PyObject * obj1 = 0 ;
36093 char * kwnames[] = {
36094 (char *) "self",(char *) "other", NULL
36095 };
36096
36097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36099 if (!SWIG_IsOK(res1)) {
36100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36101 }
36102 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36103 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36104 if (!SWIG_IsOK(res2)) {
36105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36106 }
36107 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36108 {
36109 PyThreadState* __tstate = wxPyBeginAllowThreads();
36110 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36111 wxPyEndAllowThreads(__tstate);
36112 if (PyErr_Occurred()) SWIG_fail;
36113 }
36114 {
36115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36116 }
36117 return resultobj;
36118 fail:
36119 return NULL;
36120 }
36121
36122
36123 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36124 PyObject *resultobj = 0;
36125 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36126 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36127 bool result;
36128 void *argp1 = 0 ;
36129 int res1 = 0 ;
36130 void *argp2 = 0 ;
36131 int res2 = 0 ;
36132 PyObject * obj0 = 0 ;
36133 PyObject * obj1 = 0 ;
36134 char * kwnames[] = {
36135 (char *) "self",(char *) "other", NULL
36136 };
36137
36138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36140 if (!SWIG_IsOK(res1)) {
36141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36142 }
36143 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36145 if (!SWIG_IsOK(res2)) {
36146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36147 }
36148 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36149 {
36150 PyThreadState* __tstate = wxPyBeginAllowThreads();
36151 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36152 wxPyEndAllowThreads(__tstate);
36153 if (PyErr_Occurred()) SWIG_fail;
36154 }
36155 {
36156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36157 }
36158 return resultobj;
36159 fail:
36160 return NULL;
36161 }
36162
36163
36164 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36165 PyObject *resultobj = 0;
36166 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36167 int arg2 ;
36168 void *argp1 = 0 ;
36169 int res1 = 0 ;
36170 int val2 ;
36171 int ecode2 = 0 ;
36172 PyObject *swig_obj[2] ;
36173
36174 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36176 if (!SWIG_IsOK(res1)) {
36177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36178 }
36179 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36180 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36181 if (!SWIG_IsOK(ecode2)) {
36182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36183 }
36184 arg2 = static_cast< int >(val2);
36185 if (arg1) (arg1)->w = arg2;
36186
36187 resultobj = SWIG_Py_Void();
36188 return resultobj;
36189 fail:
36190 return NULL;
36191 }
36192
36193
36194 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36195 PyObject *resultobj = 0;
36196 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36197 int result;
36198 void *argp1 = 0 ;
36199 int res1 = 0 ;
36200 PyObject *swig_obj[1] ;
36201
36202 if (!args) SWIG_fail;
36203 swig_obj[0] = args;
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_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36207 }
36208 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36209 result = (int) ((arg1)->w);
36210 resultobj = SWIG_From_int(static_cast< int >(result));
36211 return resultobj;
36212 fail:
36213 return NULL;
36214 }
36215
36216
36217 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36218 PyObject *resultobj = 0;
36219 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36220 int arg2 ;
36221 void *argp1 = 0 ;
36222 int res1 = 0 ;
36223 int val2 ;
36224 int ecode2 = 0 ;
36225 PyObject *swig_obj[2] ;
36226
36227 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36229 if (!SWIG_IsOK(res1)) {
36230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36231 }
36232 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36233 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36234 if (!SWIG_IsOK(ecode2)) {
36235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36236 }
36237 arg2 = static_cast< int >(val2);
36238 if (arg1) (arg1)->h = arg2;
36239
36240 resultobj = SWIG_Py_Void();
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36248 PyObject *resultobj = 0;
36249 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36250 int result;
36251 void *argp1 = 0 ;
36252 int res1 = 0 ;
36253 PyObject *swig_obj[1] ;
36254
36255 if (!args) SWIG_fail;
36256 swig_obj[0] = args;
36257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36258 if (!SWIG_IsOK(res1)) {
36259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36260 }
36261 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36262 result = (int) ((arg1)->h);
36263 resultobj = SWIG_From_int(static_cast< int >(result));
36264 return resultobj;
36265 fail:
36266 return NULL;
36267 }
36268
36269
36270 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36271 PyObject *resultobj = 0;
36272 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36273 int arg2 ;
36274 void *argp1 = 0 ;
36275 int res1 = 0 ;
36276 int val2 ;
36277 int ecode2 = 0 ;
36278 PyObject *swig_obj[2] ;
36279
36280 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36282 if (!SWIG_IsOK(res1)) {
36283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36284 }
36285 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36286 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36287 if (!SWIG_IsOK(ecode2)) {
36288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36289 }
36290 arg2 = static_cast< int >(val2);
36291 if (arg1) (arg1)->bpp = arg2;
36292
36293 resultobj = SWIG_Py_Void();
36294 return resultobj;
36295 fail:
36296 return NULL;
36297 }
36298
36299
36300 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36301 PyObject *resultobj = 0;
36302 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36303 int result;
36304 void *argp1 = 0 ;
36305 int res1 = 0 ;
36306 PyObject *swig_obj[1] ;
36307
36308 if (!args) SWIG_fail;
36309 swig_obj[0] = args;
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_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36313 }
36314 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36315 result = (int) ((arg1)->bpp);
36316 resultobj = SWIG_From_int(static_cast< int >(result));
36317 return resultobj;
36318 fail:
36319 return NULL;
36320 }
36321
36322
36323 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36324 PyObject *resultobj = 0;
36325 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36326 int arg2 ;
36327 void *argp1 = 0 ;
36328 int res1 = 0 ;
36329 int val2 ;
36330 int ecode2 = 0 ;
36331 PyObject *swig_obj[2] ;
36332
36333 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36335 if (!SWIG_IsOK(res1)) {
36336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36337 }
36338 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36339 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36340 if (!SWIG_IsOK(ecode2)) {
36341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36342 }
36343 arg2 = static_cast< int >(val2);
36344 if (arg1) (arg1)->refresh = arg2;
36345
36346 resultobj = SWIG_Py_Void();
36347 return resultobj;
36348 fail:
36349 return NULL;
36350 }
36351
36352
36353 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36354 PyObject *resultobj = 0;
36355 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36356 int result;
36357 void *argp1 = 0 ;
36358 int res1 = 0 ;
36359 PyObject *swig_obj[1] ;
36360
36361 if (!args) SWIG_fail;
36362 swig_obj[0] = args;
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_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36366 }
36367 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36368 result = (int) ((arg1)->refresh);
36369 resultobj = SWIG_From_int(static_cast< int >(result));
36370 return resultobj;
36371 fail:
36372 return NULL;
36373 }
36374
36375
36376 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36377 PyObject *obj;
36378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36379 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36380 return SWIG_Py_Void();
36381 }
36382
36383 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36384 return SWIG_Python_InitShadowInstance(args);
36385 }
36386
36387 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36388 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36389 return 1;
36390 }
36391
36392
36393 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36394 PyObject *pyobj = 0;
36395
36396 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36397 return pyobj;
36398 }
36399
36400
36401 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36402 PyObject *resultobj = 0;
36403 unsigned int arg1 = (unsigned int) 0 ;
36404 wxDisplay *result = 0 ;
36405 unsigned int val1 ;
36406 int ecode1 = 0 ;
36407 PyObject * obj0 = 0 ;
36408 char * kwnames[] = {
36409 (char *) "index", NULL
36410 };
36411
36412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36413 if (obj0) {
36414 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36415 if (!SWIG_IsOK(ecode1)) {
36416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36417 }
36418 arg1 = static_cast< unsigned int >(val1);
36419 }
36420 {
36421 PyThreadState* __tstate = wxPyBeginAllowThreads();
36422 result = (wxDisplay *)new wxDisplay(arg1);
36423 wxPyEndAllowThreads(__tstate);
36424 if (PyErr_Occurred()) SWIG_fail;
36425 }
36426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36427 return resultobj;
36428 fail:
36429 return NULL;
36430 }
36431
36432
36433 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36434 PyObject *resultobj = 0;
36435 wxDisplay *arg1 = (wxDisplay *) 0 ;
36436 void *argp1 = 0 ;
36437 int res1 = 0 ;
36438 PyObject *swig_obj[1] ;
36439
36440 if (!args) SWIG_fail;
36441 swig_obj[0] = args;
36442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36443 if (!SWIG_IsOK(res1)) {
36444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36445 }
36446 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 delete arg1;
36450
36451 wxPyEndAllowThreads(__tstate);
36452 if (PyErr_Occurred()) SWIG_fail;
36453 }
36454 resultobj = SWIG_Py_Void();
36455 return resultobj;
36456 fail:
36457 return NULL;
36458 }
36459
36460
36461 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36462 PyObject *resultobj = 0;
36463 unsigned int result;
36464
36465 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36466 {
36467 PyThreadState* __tstate = wxPyBeginAllowThreads();
36468 result = (unsigned int)wxDisplay::GetCount();
36469 wxPyEndAllowThreads(__tstate);
36470 if (PyErr_Occurred()) SWIG_fail;
36471 }
36472 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36473 return resultobj;
36474 fail:
36475 return NULL;
36476 }
36477
36478
36479 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36480 PyObject *resultobj = 0;
36481 wxPoint *arg1 = 0 ;
36482 int result;
36483 wxPoint temp1 ;
36484 PyObject * obj0 = 0 ;
36485 char * kwnames[] = {
36486 (char *) "pt", NULL
36487 };
36488
36489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36490 {
36491 arg1 = &temp1;
36492 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36493 }
36494 {
36495 PyThreadState* __tstate = wxPyBeginAllowThreads();
36496 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36497 wxPyEndAllowThreads(__tstate);
36498 if (PyErr_Occurred()) SWIG_fail;
36499 }
36500 resultobj = SWIG_From_int(static_cast< int >(result));
36501 return resultobj;
36502 fail:
36503 return NULL;
36504 }
36505
36506
36507 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36508 PyObject *resultobj = 0;
36509 wxWindow *arg1 = (wxWindow *) 0 ;
36510 int result;
36511 void *argp1 = 0 ;
36512 int res1 = 0 ;
36513 PyObject * obj0 = 0 ;
36514 char * kwnames[] = {
36515 (char *) "window", NULL
36516 };
36517
36518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36520 if (!SWIG_IsOK(res1)) {
36521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36522 }
36523 arg1 = reinterpret_cast< wxWindow * >(argp1);
36524 {
36525 PyThreadState* __tstate = wxPyBeginAllowThreads();
36526 result = (int)wxDisplay::GetFromWindow(arg1);
36527 wxPyEndAllowThreads(__tstate);
36528 if (PyErr_Occurred()) SWIG_fail;
36529 }
36530 resultobj = SWIG_From_int(static_cast< int >(result));
36531 return resultobj;
36532 fail:
36533 return NULL;
36534 }
36535
36536
36537 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36538 PyObject *resultobj = 0;
36539 wxDisplay *arg1 = (wxDisplay *) 0 ;
36540 bool result;
36541 void *argp1 = 0 ;
36542 int res1 = 0 ;
36543 PyObject *swig_obj[1] ;
36544
36545 if (!args) SWIG_fail;
36546 swig_obj[0] = args;
36547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36548 if (!SWIG_IsOK(res1)) {
36549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36550 }
36551 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36552 {
36553 PyThreadState* __tstate = wxPyBeginAllowThreads();
36554 result = (bool)((wxDisplay const *)arg1)->IsOk();
36555 wxPyEndAllowThreads(__tstate);
36556 if (PyErr_Occurred()) SWIG_fail;
36557 }
36558 {
36559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36560 }
36561 return resultobj;
36562 fail:
36563 return NULL;
36564 }
36565
36566
36567 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36568 PyObject *resultobj = 0;
36569 wxDisplay *arg1 = (wxDisplay *) 0 ;
36570 wxRect result;
36571 void *argp1 = 0 ;
36572 int res1 = 0 ;
36573 PyObject *swig_obj[1] ;
36574
36575 if (!args) SWIG_fail;
36576 swig_obj[0] = args;
36577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36578 if (!SWIG_IsOK(res1)) {
36579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36580 }
36581 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36582 {
36583 PyThreadState* __tstate = wxPyBeginAllowThreads();
36584 result = ((wxDisplay const *)arg1)->GetGeometry();
36585 wxPyEndAllowThreads(__tstate);
36586 if (PyErr_Occurred()) SWIG_fail;
36587 }
36588 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36589 return resultobj;
36590 fail:
36591 return NULL;
36592 }
36593
36594
36595 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36596 PyObject *resultobj = 0;
36597 wxDisplay *arg1 = (wxDisplay *) 0 ;
36598 wxRect result;
36599 void *argp1 = 0 ;
36600 int res1 = 0 ;
36601 PyObject *swig_obj[1] ;
36602
36603 if (!args) SWIG_fail;
36604 swig_obj[0] = args;
36605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36606 if (!SWIG_IsOK(res1)) {
36607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36608 }
36609 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 result = ((wxDisplay const *)arg1)->GetClientArea();
36613 wxPyEndAllowThreads(__tstate);
36614 if (PyErr_Occurred()) SWIG_fail;
36615 }
36616 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36617 return resultobj;
36618 fail:
36619 return NULL;
36620 }
36621
36622
36623 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36624 PyObject *resultobj = 0;
36625 wxDisplay *arg1 = (wxDisplay *) 0 ;
36626 wxString result;
36627 void *argp1 = 0 ;
36628 int res1 = 0 ;
36629 PyObject *swig_obj[1] ;
36630
36631 if (!args) SWIG_fail;
36632 swig_obj[0] = args;
36633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36634 if (!SWIG_IsOK(res1)) {
36635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36636 }
36637 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36638 {
36639 PyThreadState* __tstate = wxPyBeginAllowThreads();
36640 result = ((wxDisplay const *)arg1)->GetName();
36641 wxPyEndAllowThreads(__tstate);
36642 if (PyErr_Occurred()) SWIG_fail;
36643 }
36644 {
36645 #if wxUSE_UNICODE
36646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36647 #else
36648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36649 #endif
36650 }
36651 return resultobj;
36652 fail:
36653 return NULL;
36654 }
36655
36656
36657 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36658 PyObject *resultobj = 0;
36659 wxDisplay *arg1 = (wxDisplay *) 0 ;
36660 bool result;
36661 void *argp1 = 0 ;
36662 int res1 = 0 ;
36663 PyObject *swig_obj[1] ;
36664
36665 if (!args) SWIG_fail;
36666 swig_obj[0] = args;
36667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36668 if (!SWIG_IsOK(res1)) {
36669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36670 }
36671 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36675 wxPyEndAllowThreads(__tstate);
36676 if (PyErr_Occurred()) SWIG_fail;
36677 }
36678 {
36679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36680 }
36681 return resultobj;
36682 fail:
36683 return NULL;
36684 }
36685
36686
36687 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36688 PyObject *resultobj = 0;
36689 wxDisplay *arg1 = (wxDisplay *) 0 ;
36690 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36691 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36692 PyObject *result = 0 ;
36693 void *argp1 = 0 ;
36694 int res1 = 0 ;
36695 void *argp2 = 0 ;
36696 int res2 = 0 ;
36697 PyObject * obj0 = 0 ;
36698 PyObject * obj1 = 0 ;
36699 char * kwnames[] = {
36700 (char *) "self",(char *) "mode", NULL
36701 };
36702
36703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36705 if (!SWIG_IsOK(res1)) {
36706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36707 }
36708 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36709 if (obj1) {
36710 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36711 if (!SWIG_IsOK(res2)) {
36712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36713 }
36714 if (!argp2) {
36715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36716 }
36717 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36718 }
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36722 wxPyEndAllowThreads(__tstate);
36723 if (PyErr_Occurred()) SWIG_fail;
36724 }
36725 resultobj = result;
36726 return resultobj;
36727 fail:
36728 return NULL;
36729 }
36730
36731
36732 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36733 PyObject *resultobj = 0;
36734 wxDisplay *arg1 = (wxDisplay *) 0 ;
36735 wxVideoMode result;
36736 void *argp1 = 0 ;
36737 int res1 = 0 ;
36738 PyObject *swig_obj[1] ;
36739
36740 if (!args) SWIG_fail;
36741 swig_obj[0] = args;
36742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36743 if (!SWIG_IsOK(res1)) {
36744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36745 }
36746 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36747 {
36748 PyThreadState* __tstate = wxPyBeginAllowThreads();
36749 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36750 wxPyEndAllowThreads(__tstate);
36751 if (PyErr_Occurred()) SWIG_fail;
36752 }
36753 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36754 return resultobj;
36755 fail:
36756 return NULL;
36757 }
36758
36759
36760 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36761 PyObject *resultobj = 0;
36762 wxDisplay *arg1 = (wxDisplay *) 0 ;
36763 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36764 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36765 bool result;
36766 void *argp1 = 0 ;
36767 int res1 = 0 ;
36768 void *argp2 = 0 ;
36769 int res2 = 0 ;
36770 PyObject * obj0 = 0 ;
36771 PyObject * obj1 = 0 ;
36772 char * kwnames[] = {
36773 (char *) "self",(char *) "mode", NULL
36774 };
36775
36776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36778 if (!SWIG_IsOK(res1)) {
36779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36780 }
36781 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36782 if (obj1) {
36783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36784 if (!SWIG_IsOK(res2)) {
36785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36786 }
36787 if (!argp2) {
36788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36789 }
36790 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36791 }
36792 {
36793 PyThreadState* __tstate = wxPyBeginAllowThreads();
36794 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36795 wxPyEndAllowThreads(__tstate);
36796 if (PyErr_Occurred()) SWIG_fail;
36797 }
36798 {
36799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36800 }
36801 return resultobj;
36802 fail:
36803 return NULL;
36804 }
36805
36806
36807 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36808 PyObject *resultobj = 0;
36809 wxDisplay *arg1 = (wxDisplay *) 0 ;
36810 void *argp1 = 0 ;
36811 int res1 = 0 ;
36812 PyObject *swig_obj[1] ;
36813
36814 if (!args) SWIG_fail;
36815 swig_obj[0] = args;
36816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36817 if (!SWIG_IsOK(res1)) {
36818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36819 }
36820 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36821 {
36822 PyThreadState* __tstate = wxPyBeginAllowThreads();
36823 wxDisplay_ResetMode(arg1);
36824 wxPyEndAllowThreads(__tstate);
36825 if (PyErr_Occurred()) SWIG_fail;
36826 }
36827 resultobj = SWIG_Py_Void();
36828 return resultobj;
36829 fail:
36830 return NULL;
36831 }
36832
36833
36834 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36835 PyObject *obj;
36836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36837 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36838 return SWIG_Py_Void();
36839 }
36840
36841 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36842 return SWIG_Python_InitShadowInstance(args);
36843 }
36844
36845 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36846 PyObject *resultobj = 0;
36847 wxStandardPaths *result = 0 ;
36848
36849 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36850 {
36851 PyThreadState* __tstate = wxPyBeginAllowThreads();
36852 result = (wxStandardPaths *)wxStandardPaths_Get();
36853 wxPyEndAllowThreads(__tstate);
36854 if (PyErr_Occurred()) SWIG_fail;
36855 }
36856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36857 return resultobj;
36858 fail:
36859 return NULL;
36860 }
36861
36862
36863 SWIGINTERN PyObject *_wrap_StandardPaths_GetExecutablePath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36864 PyObject *resultobj = 0;
36865 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36866 wxString result;
36867 void *argp1 = 0 ;
36868 int res1 = 0 ;
36869 PyObject *swig_obj[1] ;
36870
36871 if (!args) SWIG_fail;
36872 swig_obj[0] = args;
36873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36874 if (!SWIG_IsOK(res1)) {
36875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetExecutablePath" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36876 }
36877 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36878 {
36879 PyThreadState* __tstate = wxPyBeginAllowThreads();
36880 result = ((wxStandardPaths const *)arg1)->GetExecutablePath();
36881 wxPyEndAllowThreads(__tstate);
36882 if (PyErr_Occurred()) SWIG_fail;
36883 }
36884 {
36885 #if wxUSE_UNICODE
36886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36887 #else
36888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36889 #endif
36890 }
36891 return resultobj;
36892 fail:
36893 return NULL;
36894 }
36895
36896
36897 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36898 PyObject *resultobj = 0;
36899 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36900 wxString result;
36901 void *argp1 = 0 ;
36902 int res1 = 0 ;
36903 PyObject *swig_obj[1] ;
36904
36905 if (!args) SWIG_fail;
36906 swig_obj[0] = args;
36907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36908 if (!SWIG_IsOK(res1)) {
36909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36910 }
36911 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36912 {
36913 PyThreadState* __tstate = wxPyBeginAllowThreads();
36914 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36915 wxPyEndAllowThreads(__tstate);
36916 if (PyErr_Occurred()) SWIG_fail;
36917 }
36918 {
36919 #if wxUSE_UNICODE
36920 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36921 #else
36922 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36923 #endif
36924 }
36925 return resultobj;
36926 fail:
36927 return NULL;
36928 }
36929
36930
36931 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36932 PyObject *resultobj = 0;
36933 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36934 wxString result;
36935 void *argp1 = 0 ;
36936 int res1 = 0 ;
36937 PyObject *swig_obj[1] ;
36938
36939 if (!args) SWIG_fail;
36940 swig_obj[0] = args;
36941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36942 if (!SWIG_IsOK(res1)) {
36943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36944 }
36945 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36946 {
36947 PyThreadState* __tstate = wxPyBeginAllowThreads();
36948 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36949 wxPyEndAllowThreads(__tstate);
36950 if (PyErr_Occurred()) SWIG_fail;
36951 }
36952 {
36953 #if wxUSE_UNICODE
36954 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36955 #else
36956 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36957 #endif
36958 }
36959 return resultobj;
36960 fail:
36961 return NULL;
36962 }
36963
36964
36965 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36966 PyObject *resultobj = 0;
36967 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36968 wxString result;
36969 void *argp1 = 0 ;
36970 int res1 = 0 ;
36971 PyObject *swig_obj[1] ;
36972
36973 if (!args) SWIG_fail;
36974 swig_obj[0] = args;
36975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36976 if (!SWIG_IsOK(res1)) {
36977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36978 }
36979 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36980 {
36981 PyThreadState* __tstate = wxPyBeginAllowThreads();
36982 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36983 wxPyEndAllowThreads(__tstate);
36984 if (PyErr_Occurred()) SWIG_fail;
36985 }
36986 {
36987 #if wxUSE_UNICODE
36988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36989 #else
36990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36991 #endif
36992 }
36993 return resultobj;
36994 fail:
36995 return NULL;
36996 }
36997
36998
36999 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37000 PyObject *resultobj = 0;
37001 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37002 wxString result;
37003 void *argp1 = 0 ;
37004 int res1 = 0 ;
37005 PyObject *swig_obj[1] ;
37006
37007 if (!args) SWIG_fail;
37008 swig_obj[0] = args;
37009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37010 if (!SWIG_IsOK(res1)) {
37011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37012 }
37013 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37014 {
37015 PyThreadState* __tstate = wxPyBeginAllowThreads();
37016 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
37017 wxPyEndAllowThreads(__tstate);
37018 if (PyErr_Occurred()) SWIG_fail;
37019 }
37020 {
37021 #if wxUSE_UNICODE
37022 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37023 #else
37024 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37025 #endif
37026 }
37027 return resultobj;
37028 fail:
37029 return NULL;
37030 }
37031
37032
37033 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37034 PyObject *resultobj = 0;
37035 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37036 wxString result;
37037 void *argp1 = 0 ;
37038 int res1 = 0 ;
37039 PyObject *swig_obj[1] ;
37040
37041 if (!args) SWIG_fail;
37042 swig_obj[0] = args;
37043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37044 if (!SWIG_IsOK(res1)) {
37045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37046 }
37047 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37048 {
37049 PyThreadState* __tstate = wxPyBeginAllowThreads();
37050 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
37051 wxPyEndAllowThreads(__tstate);
37052 if (PyErr_Occurred()) SWIG_fail;
37053 }
37054 {
37055 #if wxUSE_UNICODE
37056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37057 #else
37058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37059 #endif
37060 }
37061 return resultobj;
37062 fail:
37063 return NULL;
37064 }
37065
37066
37067 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37068 PyObject *resultobj = 0;
37069 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37070 wxString result;
37071 void *argp1 = 0 ;
37072 int res1 = 0 ;
37073 PyObject *swig_obj[1] ;
37074
37075 if (!args) SWIG_fail;
37076 swig_obj[0] = args;
37077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37078 if (!SWIG_IsOK(res1)) {
37079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37080 }
37081 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37082 {
37083 PyThreadState* __tstate = wxPyBeginAllowThreads();
37084 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37085 wxPyEndAllowThreads(__tstate);
37086 if (PyErr_Occurred()) SWIG_fail;
37087 }
37088 {
37089 #if wxUSE_UNICODE
37090 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37091 #else
37092 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37093 #endif
37094 }
37095 return resultobj;
37096 fail:
37097 return NULL;
37098 }
37099
37100
37101 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37102 PyObject *resultobj = 0;
37103 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37104 wxString result;
37105 void *argp1 = 0 ;
37106 int res1 = 0 ;
37107 PyObject *swig_obj[1] ;
37108
37109 if (!args) SWIG_fail;
37110 swig_obj[0] = args;
37111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37112 if (!SWIG_IsOK(res1)) {
37113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37114 }
37115 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37116 {
37117 PyThreadState* __tstate = wxPyBeginAllowThreads();
37118 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37119 wxPyEndAllowThreads(__tstate);
37120 if (PyErr_Occurred()) SWIG_fail;
37121 }
37122 {
37123 #if wxUSE_UNICODE
37124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37125 #else
37126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37127 #endif
37128 }
37129 return resultobj;
37130 fail:
37131 return NULL;
37132 }
37133
37134
37135 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37136 PyObject *resultobj = 0;
37137 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37138 wxString result;
37139 void *argp1 = 0 ;
37140 int res1 = 0 ;
37141 PyObject *swig_obj[1] ;
37142
37143 if (!args) SWIG_fail;
37144 swig_obj[0] = args;
37145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37146 if (!SWIG_IsOK(res1)) {
37147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37148 }
37149 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37150 {
37151 PyThreadState* __tstate = wxPyBeginAllowThreads();
37152 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37153 wxPyEndAllowThreads(__tstate);
37154 if (PyErr_Occurred()) SWIG_fail;
37155 }
37156 {
37157 #if wxUSE_UNICODE
37158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37159 #else
37160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37161 #endif
37162 }
37163 return resultobj;
37164 fail:
37165 return NULL;
37166 }
37167
37168
37169 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37170 PyObject *resultobj = 0;
37171 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37172 wxString *arg2 = 0 ;
37173 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37174 wxString result;
37175 void *argp1 = 0 ;
37176 int res1 = 0 ;
37177 bool temp2 = false ;
37178 int val3 ;
37179 int ecode3 = 0 ;
37180 PyObject * obj0 = 0 ;
37181 PyObject * obj1 = 0 ;
37182 PyObject * obj2 = 0 ;
37183 char * kwnames[] = {
37184 (char *) "self",(char *) "lang",(char *) "category", NULL
37185 };
37186
37187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37189 if (!SWIG_IsOK(res1)) {
37190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37191 }
37192 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37193 {
37194 arg2 = wxString_in_helper(obj1);
37195 if (arg2 == NULL) SWIG_fail;
37196 temp2 = true;
37197 }
37198 if (obj2) {
37199 ecode3 = SWIG_AsVal_int(obj2, &val3);
37200 if (!SWIG_IsOK(ecode3)) {
37201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37202 }
37203 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37204 }
37205 {
37206 PyThreadState* __tstate = wxPyBeginAllowThreads();
37207 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37208 wxPyEndAllowThreads(__tstate);
37209 if (PyErr_Occurred()) SWIG_fail;
37210 }
37211 {
37212 #if wxUSE_UNICODE
37213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37214 #else
37215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37216 #endif
37217 }
37218 {
37219 if (temp2)
37220 delete arg2;
37221 }
37222 return resultobj;
37223 fail:
37224 {
37225 if (temp2)
37226 delete arg2;
37227 }
37228 return NULL;
37229 }
37230
37231
37232 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37233 PyObject *resultobj = 0;
37234 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37235 wxString result;
37236 void *argp1 = 0 ;
37237 int res1 = 0 ;
37238 PyObject *swig_obj[1] ;
37239
37240 if (!args) SWIG_fail;
37241 swig_obj[0] = args;
37242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37243 if (!SWIG_IsOK(res1)) {
37244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37245 }
37246 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37247 {
37248 PyThreadState* __tstate = wxPyBeginAllowThreads();
37249 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37250 wxPyEndAllowThreads(__tstate);
37251 if (PyErr_Occurred()) SWIG_fail;
37252 }
37253 {
37254 #if wxUSE_UNICODE
37255 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37256 #else
37257 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37258 #endif
37259 }
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37267 PyObject *resultobj = 0;
37268 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37269 wxString result;
37270 void *argp1 = 0 ;
37271 int res1 = 0 ;
37272 PyObject *swig_obj[1] ;
37273
37274 if (!args) SWIG_fail;
37275 swig_obj[0] = args;
37276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37277 if (!SWIG_IsOK(res1)) {
37278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37279 }
37280 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37281 {
37282 PyThreadState* __tstate = wxPyBeginAllowThreads();
37283 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37284 wxPyEndAllowThreads(__tstate);
37285 if (PyErr_Occurred()) SWIG_fail;
37286 }
37287 {
37288 #if wxUSE_UNICODE
37289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37290 #else
37291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37292 #endif
37293 }
37294 return resultobj;
37295 fail:
37296 return NULL;
37297 }
37298
37299
37300 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37301 PyObject *resultobj = 0;
37302 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37303 wxString *arg2 = 0 ;
37304 void *argp1 = 0 ;
37305 int res1 = 0 ;
37306 bool temp2 = false ;
37307 PyObject * obj0 = 0 ;
37308 PyObject * obj1 = 0 ;
37309 char * kwnames[] = {
37310 (char *) "self",(char *) "prefix", NULL
37311 };
37312
37313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37317 }
37318 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37319 {
37320 arg2 = wxString_in_helper(obj1);
37321 if (arg2 == NULL) SWIG_fail;
37322 temp2 = true;
37323 }
37324 {
37325 PyThreadState* __tstate = wxPyBeginAllowThreads();
37326 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37327 wxPyEndAllowThreads(__tstate);
37328 if (PyErr_Occurred()) SWIG_fail;
37329 }
37330 resultobj = SWIG_Py_Void();
37331 {
37332 if (temp2)
37333 delete arg2;
37334 }
37335 return resultobj;
37336 fail:
37337 {
37338 if (temp2)
37339 delete arg2;
37340 }
37341 return NULL;
37342 }
37343
37344
37345 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37346 PyObject *resultobj = 0;
37347 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37348 wxString result;
37349 void *argp1 = 0 ;
37350 int res1 = 0 ;
37351 PyObject *swig_obj[1] ;
37352
37353 if (!args) SWIG_fail;
37354 swig_obj[0] = args;
37355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37356 if (!SWIG_IsOK(res1)) {
37357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37358 }
37359 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37360 {
37361 PyThreadState* __tstate = wxPyBeginAllowThreads();
37362 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37363 wxPyEndAllowThreads(__tstate);
37364 if (PyErr_Occurred()) SWIG_fail;
37365 }
37366 {
37367 #if wxUSE_UNICODE
37368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37369 #else
37370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37371 #endif
37372 }
37373 return resultobj;
37374 fail:
37375 return NULL;
37376 }
37377
37378
37379 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37380 PyObject *obj;
37381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37382 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37383 return SWIG_Py_Void();
37384 }
37385
37386 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37387 PyObject *resultobj = 0;
37388 wxEventType arg1 ;
37389 wxPowerEvent *result = 0 ;
37390 int val1 ;
37391 int ecode1 = 0 ;
37392 PyObject * obj0 = 0 ;
37393 char * kwnames[] = {
37394 (char *) "evtType", NULL
37395 };
37396
37397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37398 ecode1 = SWIG_AsVal_int(obj0, &val1);
37399 if (!SWIG_IsOK(ecode1)) {
37400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37401 }
37402 arg1 = static_cast< wxEventType >(val1);
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37410 return resultobj;
37411 fail:
37412 return NULL;
37413 }
37414
37415
37416 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37417 PyObject *resultobj = 0;
37418 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37419 void *argp1 = 0 ;
37420 int res1 = 0 ;
37421 PyObject *swig_obj[1] ;
37422
37423 if (!args) SWIG_fail;
37424 swig_obj[0] = args;
37425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37426 if (!SWIG_IsOK(res1)) {
37427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37428 }
37429 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37430 {
37431 PyThreadState* __tstate = wxPyBeginAllowThreads();
37432 (arg1)->Veto();
37433 wxPyEndAllowThreads(__tstate);
37434 if (PyErr_Occurred()) SWIG_fail;
37435 }
37436 resultobj = SWIG_Py_Void();
37437 return resultobj;
37438 fail:
37439 return NULL;
37440 }
37441
37442
37443 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37444 PyObject *resultobj = 0;
37445 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37446 bool result;
37447 void *argp1 = 0 ;
37448 int res1 = 0 ;
37449 PyObject *swig_obj[1] ;
37450
37451 if (!args) SWIG_fail;
37452 swig_obj[0] = args;
37453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37454 if (!SWIG_IsOK(res1)) {
37455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37456 }
37457 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37458 {
37459 PyThreadState* __tstate = wxPyBeginAllowThreads();
37460 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37461 wxPyEndAllowThreads(__tstate);
37462 if (PyErr_Occurred()) SWIG_fail;
37463 }
37464 {
37465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37466 }
37467 return resultobj;
37468 fail:
37469 return NULL;
37470 }
37471
37472
37473 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37474 PyObject *obj;
37475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37476 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37477 return SWIG_Py_Void();
37478 }
37479
37480 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37481 return SWIG_Python_InitShadowInstance(args);
37482 }
37483
37484 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37485 PyObject *resultobj = 0;
37486 wxPowerType result;
37487
37488 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37489 {
37490 PyThreadState* __tstate = wxPyBeginAllowThreads();
37491 result = (wxPowerType)wxGetPowerType();
37492 wxPyEndAllowThreads(__tstate);
37493 if (PyErr_Occurred()) SWIG_fail;
37494 }
37495 resultobj = SWIG_From_int(static_cast< int >(result));
37496 return resultobj;
37497 fail:
37498 return NULL;
37499 }
37500
37501
37502 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37503 PyObject *resultobj = 0;
37504 wxBatteryState result;
37505
37506 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37507 {
37508 PyThreadState* __tstate = wxPyBeginAllowThreads();
37509 result = (wxBatteryState)wxGetBatteryState();
37510 wxPyEndAllowThreads(__tstate);
37511 if (PyErr_Occurred()) SWIG_fail;
37512 }
37513 resultobj = SWIG_From_int(static_cast< int >(result));
37514 return resultobj;
37515 fail:
37516 return NULL;
37517 }
37518
37519
37520 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37521 PyObject *resultobj = 0;
37522 wxAboutDialogInfo *result = 0 ;
37523
37524 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37525 {
37526 PyThreadState* __tstate = wxPyBeginAllowThreads();
37527 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37528 wxPyEndAllowThreads(__tstate);
37529 if (PyErr_Occurred()) SWIG_fail;
37530 }
37531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37532 return resultobj;
37533 fail:
37534 return NULL;
37535 }
37536
37537
37538 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37539 PyObject *resultobj = 0;
37540 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37541 void *argp1 = 0 ;
37542 int res1 = 0 ;
37543 PyObject *swig_obj[1] ;
37544
37545 if (!args) SWIG_fail;
37546 swig_obj[0] = args;
37547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37548 if (!SWIG_IsOK(res1)) {
37549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37550 }
37551 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37552 {
37553 PyThreadState* __tstate = wxPyBeginAllowThreads();
37554 delete arg1;
37555
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 resultobj = SWIG_Py_Void();
37560 return resultobj;
37561 fail:
37562 return NULL;
37563 }
37564
37565
37566 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37567 PyObject *resultobj = 0;
37568 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37569 wxString *arg2 = 0 ;
37570 void *argp1 = 0 ;
37571 int res1 = 0 ;
37572 bool temp2 = false ;
37573 PyObject * obj0 = 0 ;
37574 PyObject * obj1 = 0 ;
37575 char * kwnames[] = {
37576 (char *) "self",(char *) "name", NULL
37577 };
37578
37579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37581 if (!SWIG_IsOK(res1)) {
37582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37583 }
37584 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37585 {
37586 arg2 = wxString_in_helper(obj1);
37587 if (arg2 == NULL) SWIG_fail;
37588 temp2 = true;
37589 }
37590 {
37591 PyThreadState* __tstate = wxPyBeginAllowThreads();
37592 (arg1)->SetName((wxString const &)*arg2);
37593 wxPyEndAllowThreads(__tstate);
37594 if (PyErr_Occurred()) SWIG_fail;
37595 }
37596 resultobj = SWIG_Py_Void();
37597 {
37598 if (temp2)
37599 delete arg2;
37600 }
37601 return resultobj;
37602 fail:
37603 {
37604 if (temp2)
37605 delete arg2;
37606 }
37607 return NULL;
37608 }
37609
37610
37611 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37612 PyObject *resultobj = 0;
37613 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37614 wxString result;
37615 void *argp1 = 0 ;
37616 int res1 = 0 ;
37617 PyObject *swig_obj[1] ;
37618
37619 if (!args) SWIG_fail;
37620 swig_obj[0] = args;
37621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37622 if (!SWIG_IsOK(res1)) {
37623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37624 }
37625 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37626 {
37627 PyThreadState* __tstate = wxPyBeginAllowThreads();
37628 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37629 wxPyEndAllowThreads(__tstate);
37630 if (PyErr_Occurred()) SWIG_fail;
37631 }
37632 {
37633 #if wxUSE_UNICODE
37634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37635 #else
37636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37637 #endif
37638 }
37639 return resultobj;
37640 fail:
37641 return NULL;
37642 }
37643
37644
37645 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37646 PyObject *resultobj = 0;
37647 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37648 wxString *arg2 = 0 ;
37649 void *argp1 = 0 ;
37650 int res1 = 0 ;
37651 bool temp2 = false ;
37652 PyObject * obj0 = 0 ;
37653 PyObject * obj1 = 0 ;
37654 char * kwnames[] = {
37655 (char *) "self",(char *) "version", NULL
37656 };
37657
37658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37660 if (!SWIG_IsOK(res1)) {
37661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37662 }
37663 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37664 {
37665 arg2 = wxString_in_helper(obj1);
37666 if (arg2 == NULL) SWIG_fail;
37667 temp2 = true;
37668 }
37669 {
37670 PyThreadState* __tstate = wxPyBeginAllowThreads();
37671 (arg1)->SetVersion((wxString const &)*arg2);
37672 wxPyEndAllowThreads(__tstate);
37673 if (PyErr_Occurred()) SWIG_fail;
37674 }
37675 resultobj = SWIG_Py_Void();
37676 {
37677 if (temp2)
37678 delete arg2;
37679 }
37680 return resultobj;
37681 fail:
37682 {
37683 if (temp2)
37684 delete arg2;
37685 }
37686 return NULL;
37687 }
37688
37689
37690 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37691 PyObject *resultobj = 0;
37692 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37693 bool result;
37694 void *argp1 = 0 ;
37695 int res1 = 0 ;
37696 PyObject *swig_obj[1] ;
37697
37698 if (!args) SWIG_fail;
37699 swig_obj[0] = args;
37700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37701 if (!SWIG_IsOK(res1)) {
37702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37703 }
37704 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37705 {
37706 PyThreadState* __tstate = wxPyBeginAllowThreads();
37707 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37708 wxPyEndAllowThreads(__tstate);
37709 if (PyErr_Occurred()) SWIG_fail;
37710 }
37711 {
37712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37713 }
37714 return resultobj;
37715 fail:
37716 return NULL;
37717 }
37718
37719
37720 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37721 PyObject *resultobj = 0;
37722 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37723 wxString result;
37724 void *argp1 = 0 ;
37725 int res1 = 0 ;
37726 PyObject *swig_obj[1] ;
37727
37728 if (!args) SWIG_fail;
37729 swig_obj[0] = args;
37730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37731 if (!SWIG_IsOK(res1)) {
37732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37733 }
37734 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37735 {
37736 PyThreadState* __tstate = wxPyBeginAllowThreads();
37737 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37738 wxPyEndAllowThreads(__tstate);
37739 if (PyErr_Occurred()) SWIG_fail;
37740 }
37741 {
37742 #if wxUSE_UNICODE
37743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37744 #else
37745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37746 #endif
37747 }
37748 return resultobj;
37749 fail:
37750 return NULL;
37751 }
37752
37753
37754 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37755 PyObject *resultobj = 0;
37756 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37757 wxString *arg2 = 0 ;
37758 void *argp1 = 0 ;
37759 int res1 = 0 ;
37760 bool temp2 = false ;
37761 PyObject * obj0 = 0 ;
37762 PyObject * obj1 = 0 ;
37763 char * kwnames[] = {
37764 (char *) "self",(char *) "desc", NULL
37765 };
37766
37767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37769 if (!SWIG_IsOK(res1)) {
37770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37771 }
37772 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37773 {
37774 arg2 = wxString_in_helper(obj1);
37775 if (arg2 == NULL) SWIG_fail;
37776 temp2 = true;
37777 }
37778 {
37779 PyThreadState* __tstate = wxPyBeginAllowThreads();
37780 (arg1)->SetDescription((wxString const &)*arg2);
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 resultobj = SWIG_Py_Void();
37785 {
37786 if (temp2)
37787 delete arg2;
37788 }
37789 return resultobj;
37790 fail:
37791 {
37792 if (temp2)
37793 delete arg2;
37794 }
37795 return NULL;
37796 }
37797
37798
37799 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37800 PyObject *resultobj = 0;
37801 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37802 bool result;
37803 void *argp1 = 0 ;
37804 int res1 = 0 ;
37805 PyObject *swig_obj[1] ;
37806
37807 if (!args) SWIG_fail;
37808 swig_obj[0] = args;
37809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37810 if (!SWIG_IsOK(res1)) {
37811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37812 }
37813 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37814 {
37815 PyThreadState* __tstate = wxPyBeginAllowThreads();
37816 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37817 wxPyEndAllowThreads(__tstate);
37818 if (PyErr_Occurred()) SWIG_fail;
37819 }
37820 {
37821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37822 }
37823 return resultobj;
37824 fail:
37825 return NULL;
37826 }
37827
37828
37829 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37830 PyObject *resultobj = 0;
37831 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37832 wxString result;
37833 void *argp1 = 0 ;
37834 int res1 = 0 ;
37835 PyObject *swig_obj[1] ;
37836
37837 if (!args) SWIG_fail;
37838 swig_obj[0] = args;
37839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37840 if (!SWIG_IsOK(res1)) {
37841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37842 }
37843 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37844 {
37845 PyThreadState* __tstate = wxPyBeginAllowThreads();
37846 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37847 wxPyEndAllowThreads(__tstate);
37848 if (PyErr_Occurred()) SWIG_fail;
37849 }
37850 {
37851 #if wxUSE_UNICODE
37852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37853 #else
37854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37855 #endif
37856 }
37857 return resultobj;
37858 fail:
37859 return NULL;
37860 }
37861
37862
37863 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37864 PyObject *resultobj = 0;
37865 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37866 wxString *arg2 = 0 ;
37867 void *argp1 = 0 ;
37868 int res1 = 0 ;
37869 bool temp2 = false ;
37870 PyObject * obj0 = 0 ;
37871 PyObject * obj1 = 0 ;
37872 char * kwnames[] = {
37873 (char *) "self",(char *) "copyright", NULL
37874 };
37875
37876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37878 if (!SWIG_IsOK(res1)) {
37879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37880 }
37881 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37882 {
37883 arg2 = wxString_in_helper(obj1);
37884 if (arg2 == NULL) SWIG_fail;
37885 temp2 = true;
37886 }
37887 {
37888 PyThreadState* __tstate = wxPyBeginAllowThreads();
37889 (arg1)->SetCopyright((wxString const &)*arg2);
37890 wxPyEndAllowThreads(__tstate);
37891 if (PyErr_Occurred()) SWIG_fail;
37892 }
37893 resultobj = SWIG_Py_Void();
37894 {
37895 if (temp2)
37896 delete arg2;
37897 }
37898 return resultobj;
37899 fail:
37900 {
37901 if (temp2)
37902 delete arg2;
37903 }
37904 return NULL;
37905 }
37906
37907
37908 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37909 PyObject *resultobj = 0;
37910 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37911 bool result;
37912 void *argp1 = 0 ;
37913 int res1 = 0 ;
37914 PyObject *swig_obj[1] ;
37915
37916 if (!args) SWIG_fail;
37917 swig_obj[0] = args;
37918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37919 if (!SWIG_IsOK(res1)) {
37920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37921 }
37922 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37923 {
37924 PyThreadState* __tstate = wxPyBeginAllowThreads();
37925 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37926 wxPyEndAllowThreads(__tstate);
37927 if (PyErr_Occurred()) SWIG_fail;
37928 }
37929 {
37930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37931 }
37932 return resultobj;
37933 fail:
37934 return NULL;
37935 }
37936
37937
37938 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37939 PyObject *resultobj = 0;
37940 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37941 wxString result;
37942 void *argp1 = 0 ;
37943 int res1 = 0 ;
37944 PyObject *swig_obj[1] ;
37945
37946 if (!args) SWIG_fail;
37947 swig_obj[0] = args;
37948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37949 if (!SWIG_IsOK(res1)) {
37950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37951 }
37952 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37953 {
37954 PyThreadState* __tstate = wxPyBeginAllowThreads();
37955 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37956 wxPyEndAllowThreads(__tstate);
37957 if (PyErr_Occurred()) SWIG_fail;
37958 }
37959 {
37960 #if wxUSE_UNICODE
37961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37962 #else
37963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37964 #endif
37965 }
37966 return resultobj;
37967 fail:
37968 return NULL;
37969 }
37970
37971
37972 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37973 PyObject *resultobj = 0;
37974 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37975 wxString *arg2 = 0 ;
37976 void *argp1 = 0 ;
37977 int res1 = 0 ;
37978 bool temp2 = false ;
37979 PyObject * obj0 = 0 ;
37980 PyObject * obj1 = 0 ;
37981 char * kwnames[] = {
37982 (char *) "self",(char *) "licence", NULL
37983 };
37984
37985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37987 if (!SWIG_IsOK(res1)) {
37988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37989 }
37990 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37991 {
37992 arg2 = wxString_in_helper(obj1);
37993 if (arg2 == NULL) SWIG_fail;
37994 temp2 = true;
37995 }
37996 {
37997 PyThreadState* __tstate = wxPyBeginAllowThreads();
37998 (arg1)->SetLicence((wxString const &)*arg2);
37999 wxPyEndAllowThreads(__tstate);
38000 if (PyErr_Occurred()) SWIG_fail;
38001 }
38002 resultobj = SWIG_Py_Void();
38003 {
38004 if (temp2)
38005 delete arg2;
38006 }
38007 return resultobj;
38008 fail:
38009 {
38010 if (temp2)
38011 delete arg2;
38012 }
38013 return NULL;
38014 }
38015
38016
38017 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38018 PyObject *resultobj = 0;
38019 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38020 wxString *arg2 = 0 ;
38021 void *argp1 = 0 ;
38022 int res1 = 0 ;
38023 bool temp2 = false ;
38024 PyObject * obj0 = 0 ;
38025 PyObject * obj1 = 0 ;
38026 char * kwnames[] = {
38027 (char *) "self",(char *) "licence", NULL
38028 };
38029
38030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
38031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38032 if (!SWIG_IsOK(res1)) {
38033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38034 }
38035 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38036 {
38037 arg2 = wxString_in_helper(obj1);
38038 if (arg2 == NULL) SWIG_fail;
38039 temp2 = true;
38040 }
38041 {
38042 PyThreadState* __tstate = wxPyBeginAllowThreads();
38043 (arg1)->SetLicense((wxString const &)*arg2);
38044 wxPyEndAllowThreads(__tstate);
38045 if (PyErr_Occurred()) SWIG_fail;
38046 }
38047 resultobj = SWIG_Py_Void();
38048 {
38049 if (temp2)
38050 delete arg2;
38051 }
38052 return resultobj;
38053 fail:
38054 {
38055 if (temp2)
38056 delete arg2;
38057 }
38058 return NULL;
38059 }
38060
38061
38062 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38063 PyObject *resultobj = 0;
38064 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38065 bool result;
38066 void *argp1 = 0 ;
38067 int res1 = 0 ;
38068 PyObject *swig_obj[1] ;
38069
38070 if (!args) SWIG_fail;
38071 swig_obj[0] = args;
38072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38073 if (!SWIG_IsOK(res1)) {
38074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38075 }
38076 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38077 {
38078 PyThreadState* __tstate = wxPyBeginAllowThreads();
38079 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38080 wxPyEndAllowThreads(__tstate);
38081 if (PyErr_Occurred()) SWIG_fail;
38082 }
38083 {
38084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38085 }
38086 return resultobj;
38087 fail:
38088 return NULL;
38089 }
38090
38091
38092 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38093 PyObject *resultobj = 0;
38094 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38095 wxString result;
38096 void *argp1 = 0 ;
38097 int res1 = 0 ;
38098 PyObject *swig_obj[1] ;
38099
38100 if (!args) SWIG_fail;
38101 swig_obj[0] = args;
38102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38103 if (!SWIG_IsOK(res1)) {
38104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38105 }
38106 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38107 {
38108 PyThreadState* __tstate = wxPyBeginAllowThreads();
38109 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38110 wxPyEndAllowThreads(__tstate);
38111 if (PyErr_Occurred()) SWIG_fail;
38112 }
38113 {
38114 #if wxUSE_UNICODE
38115 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38116 #else
38117 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38118 #endif
38119 }
38120 return resultobj;
38121 fail:
38122 return NULL;
38123 }
38124
38125
38126 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38127 PyObject *resultobj = 0;
38128 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38129 wxIcon *arg2 = 0 ;
38130 void *argp1 = 0 ;
38131 int res1 = 0 ;
38132 void *argp2 = 0 ;
38133 int res2 = 0 ;
38134 PyObject * obj0 = 0 ;
38135 PyObject * obj1 = 0 ;
38136 char * kwnames[] = {
38137 (char *) "self",(char *) "icon", NULL
38138 };
38139
38140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38142 if (!SWIG_IsOK(res1)) {
38143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38144 }
38145 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38147 if (!SWIG_IsOK(res2)) {
38148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38149 }
38150 if (!argp2) {
38151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38152 }
38153 arg2 = reinterpret_cast< wxIcon * >(argp2);
38154 {
38155 PyThreadState* __tstate = wxPyBeginAllowThreads();
38156 (arg1)->SetIcon((wxIcon const &)*arg2);
38157 wxPyEndAllowThreads(__tstate);
38158 if (PyErr_Occurred()) SWIG_fail;
38159 }
38160 resultobj = SWIG_Py_Void();
38161 return resultobj;
38162 fail:
38163 return NULL;
38164 }
38165
38166
38167 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38168 PyObject *resultobj = 0;
38169 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38170 bool result;
38171 void *argp1 = 0 ;
38172 int res1 = 0 ;
38173 PyObject *swig_obj[1] ;
38174
38175 if (!args) SWIG_fail;
38176 swig_obj[0] = args;
38177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38178 if (!SWIG_IsOK(res1)) {
38179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38180 }
38181 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38182 {
38183 PyThreadState* __tstate = wxPyBeginAllowThreads();
38184 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38185 wxPyEndAllowThreads(__tstate);
38186 if (PyErr_Occurred()) SWIG_fail;
38187 }
38188 {
38189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38190 }
38191 return resultobj;
38192 fail:
38193 return NULL;
38194 }
38195
38196
38197 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38198 PyObject *resultobj = 0;
38199 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38200 wxIcon result;
38201 void *argp1 = 0 ;
38202 int res1 = 0 ;
38203 PyObject *swig_obj[1] ;
38204
38205 if (!args) SWIG_fail;
38206 swig_obj[0] = args;
38207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38208 if (!SWIG_IsOK(res1)) {
38209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38210 }
38211 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38212 {
38213 PyThreadState* __tstate = wxPyBeginAllowThreads();
38214 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38215 wxPyEndAllowThreads(__tstate);
38216 if (PyErr_Occurred()) SWIG_fail;
38217 }
38218 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38219 return resultobj;
38220 fail:
38221 return NULL;
38222 }
38223
38224
38225 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38226 PyObject *resultobj = 0;
38227 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38228 wxString *arg2 = 0 ;
38229 wxString const &arg3_defvalue = wxEmptyString ;
38230 wxString *arg3 = (wxString *) &arg3_defvalue ;
38231 void *argp1 = 0 ;
38232 int res1 = 0 ;
38233 bool temp2 = false ;
38234 bool temp3 = false ;
38235 PyObject * obj0 = 0 ;
38236 PyObject * obj1 = 0 ;
38237 PyObject * obj2 = 0 ;
38238 char * kwnames[] = {
38239 (char *) "self",(char *) "url",(char *) "desc", NULL
38240 };
38241
38242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38244 if (!SWIG_IsOK(res1)) {
38245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38246 }
38247 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38248 {
38249 arg2 = wxString_in_helper(obj1);
38250 if (arg2 == NULL) SWIG_fail;
38251 temp2 = true;
38252 }
38253 if (obj2) {
38254 {
38255 arg3 = wxString_in_helper(obj2);
38256 if (arg3 == NULL) SWIG_fail;
38257 temp3 = true;
38258 }
38259 }
38260 {
38261 PyThreadState* __tstate = wxPyBeginAllowThreads();
38262 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38263 wxPyEndAllowThreads(__tstate);
38264 if (PyErr_Occurred()) SWIG_fail;
38265 }
38266 resultobj = SWIG_Py_Void();
38267 {
38268 if (temp2)
38269 delete arg2;
38270 }
38271 {
38272 if (temp3)
38273 delete arg3;
38274 }
38275 return resultobj;
38276 fail:
38277 {
38278 if (temp2)
38279 delete arg2;
38280 }
38281 {
38282 if (temp3)
38283 delete arg3;
38284 }
38285 return NULL;
38286 }
38287
38288
38289 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38290 PyObject *resultobj = 0;
38291 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38292 wxString result;
38293 void *argp1 = 0 ;
38294 int res1 = 0 ;
38295 PyObject *swig_obj[1] ;
38296
38297 if (!args) SWIG_fail;
38298 swig_obj[0] = args;
38299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38300 if (!SWIG_IsOK(res1)) {
38301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38302 }
38303 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38304 {
38305 PyThreadState* __tstate = wxPyBeginAllowThreads();
38306 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38307 wxPyEndAllowThreads(__tstate);
38308 if (PyErr_Occurred()) SWIG_fail;
38309 }
38310 {
38311 #if wxUSE_UNICODE
38312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38313 #else
38314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38315 #endif
38316 }
38317 return resultobj;
38318 fail:
38319 return NULL;
38320 }
38321
38322
38323 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38324 PyObject *resultobj = 0;
38325 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38326 wxString result;
38327 void *argp1 = 0 ;
38328 int res1 = 0 ;
38329 PyObject *swig_obj[1] ;
38330
38331 if (!args) SWIG_fail;
38332 swig_obj[0] = args;
38333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38334 if (!SWIG_IsOK(res1)) {
38335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38336 }
38337 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38338 {
38339 PyThreadState* __tstate = wxPyBeginAllowThreads();
38340 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38341 wxPyEndAllowThreads(__tstate);
38342 if (PyErr_Occurred()) SWIG_fail;
38343 }
38344 {
38345 #if wxUSE_UNICODE
38346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38347 #else
38348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38349 #endif
38350 }
38351 return resultobj;
38352 fail:
38353 return NULL;
38354 }
38355
38356
38357 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38358 PyObject *resultobj = 0;
38359 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38360 bool result;
38361 void *argp1 = 0 ;
38362 int res1 = 0 ;
38363 PyObject *swig_obj[1] ;
38364
38365 if (!args) SWIG_fail;
38366 swig_obj[0] = args;
38367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38368 if (!SWIG_IsOK(res1)) {
38369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38370 }
38371 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38372 {
38373 PyThreadState* __tstate = wxPyBeginAllowThreads();
38374 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38375 wxPyEndAllowThreads(__tstate);
38376 if (PyErr_Occurred()) SWIG_fail;
38377 }
38378 {
38379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38380 }
38381 return resultobj;
38382 fail:
38383 return NULL;
38384 }
38385
38386
38387 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38388 PyObject *resultobj = 0;
38389 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38390 wxArrayString *arg2 = 0 ;
38391 void *argp1 = 0 ;
38392 int res1 = 0 ;
38393 bool temp2 = false ;
38394 PyObject * obj0 = 0 ;
38395 PyObject * obj1 = 0 ;
38396 char * kwnames[] = {
38397 (char *) "self",(char *) "developers", NULL
38398 };
38399
38400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38402 if (!SWIG_IsOK(res1)) {
38403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38404 }
38405 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38406 {
38407 if (! PySequence_Check(obj1)) {
38408 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38409 SWIG_fail;
38410 }
38411 arg2 = new wxArrayString;
38412 temp2 = true;
38413 int i, len=PySequence_Length(obj1);
38414 for (i=0; i<len; i++) {
38415 PyObject* item = PySequence_GetItem(obj1, i);
38416 wxString* s = wxString_in_helper(item);
38417 if (PyErr_Occurred()) SWIG_fail;
38418 arg2->Add(*s);
38419 delete s;
38420 Py_DECREF(item);
38421 }
38422 }
38423 {
38424 PyThreadState* __tstate = wxPyBeginAllowThreads();
38425 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38426 wxPyEndAllowThreads(__tstate);
38427 if (PyErr_Occurred()) SWIG_fail;
38428 }
38429 resultobj = SWIG_Py_Void();
38430 {
38431 if (temp2) delete arg2;
38432 }
38433 return resultobj;
38434 fail:
38435 {
38436 if (temp2) delete arg2;
38437 }
38438 return NULL;
38439 }
38440
38441
38442 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38443 PyObject *resultobj = 0;
38444 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38445 wxString *arg2 = 0 ;
38446 void *argp1 = 0 ;
38447 int res1 = 0 ;
38448 bool temp2 = false ;
38449 PyObject * obj0 = 0 ;
38450 PyObject * obj1 = 0 ;
38451 char * kwnames[] = {
38452 (char *) "self",(char *) "developer", NULL
38453 };
38454
38455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38457 if (!SWIG_IsOK(res1)) {
38458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38459 }
38460 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38461 {
38462 arg2 = wxString_in_helper(obj1);
38463 if (arg2 == NULL) SWIG_fail;
38464 temp2 = true;
38465 }
38466 {
38467 PyThreadState* __tstate = wxPyBeginAllowThreads();
38468 (arg1)->AddDeveloper((wxString const &)*arg2);
38469 wxPyEndAllowThreads(__tstate);
38470 if (PyErr_Occurred()) SWIG_fail;
38471 }
38472 resultobj = SWIG_Py_Void();
38473 {
38474 if (temp2)
38475 delete arg2;
38476 }
38477 return resultobj;
38478 fail:
38479 {
38480 if (temp2)
38481 delete arg2;
38482 }
38483 return NULL;
38484 }
38485
38486
38487 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38488 PyObject *resultobj = 0;
38489 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38490 bool result;
38491 void *argp1 = 0 ;
38492 int res1 = 0 ;
38493 PyObject *swig_obj[1] ;
38494
38495 if (!args) SWIG_fail;
38496 swig_obj[0] = args;
38497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38498 if (!SWIG_IsOK(res1)) {
38499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38500 }
38501 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38502 {
38503 PyThreadState* __tstate = wxPyBeginAllowThreads();
38504 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38505 wxPyEndAllowThreads(__tstate);
38506 if (PyErr_Occurred()) SWIG_fail;
38507 }
38508 {
38509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38510 }
38511 return resultobj;
38512 fail:
38513 return NULL;
38514 }
38515
38516
38517 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38518 PyObject *resultobj = 0;
38519 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38520 wxArrayString *result = 0 ;
38521 void *argp1 = 0 ;
38522 int res1 = 0 ;
38523 PyObject *swig_obj[1] ;
38524
38525 if (!args) SWIG_fail;
38526 swig_obj[0] = args;
38527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38528 if (!SWIG_IsOK(res1)) {
38529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38530 }
38531 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38532 {
38533 PyThreadState* __tstate = wxPyBeginAllowThreads();
38534 {
38535 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38536 result = (wxArrayString *) &_result_ref;
38537 }
38538 wxPyEndAllowThreads(__tstate);
38539 if (PyErr_Occurred()) SWIG_fail;
38540 }
38541 {
38542 resultobj = wxArrayString2PyList_helper(*result);
38543 }
38544 return resultobj;
38545 fail:
38546 return NULL;
38547 }
38548
38549
38550 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38551 PyObject *resultobj = 0;
38552 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38553 wxArrayString *arg2 = 0 ;
38554 void *argp1 = 0 ;
38555 int res1 = 0 ;
38556 bool temp2 = false ;
38557 PyObject * obj0 = 0 ;
38558 PyObject * obj1 = 0 ;
38559 char * kwnames[] = {
38560 (char *) "self",(char *) "docwriters", NULL
38561 };
38562
38563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38565 if (!SWIG_IsOK(res1)) {
38566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38567 }
38568 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38569 {
38570 if (! PySequence_Check(obj1)) {
38571 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38572 SWIG_fail;
38573 }
38574 arg2 = new wxArrayString;
38575 temp2 = true;
38576 int i, len=PySequence_Length(obj1);
38577 for (i=0; i<len; i++) {
38578 PyObject* item = PySequence_GetItem(obj1, i);
38579 wxString* s = wxString_in_helper(item);
38580 if (PyErr_Occurred()) SWIG_fail;
38581 arg2->Add(*s);
38582 delete s;
38583 Py_DECREF(item);
38584 }
38585 }
38586 {
38587 PyThreadState* __tstate = wxPyBeginAllowThreads();
38588 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38589 wxPyEndAllowThreads(__tstate);
38590 if (PyErr_Occurred()) SWIG_fail;
38591 }
38592 resultobj = SWIG_Py_Void();
38593 {
38594 if (temp2) delete arg2;
38595 }
38596 return resultobj;
38597 fail:
38598 {
38599 if (temp2) delete arg2;
38600 }
38601 return NULL;
38602 }
38603
38604
38605 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38606 PyObject *resultobj = 0;
38607 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38608 wxString *arg2 = 0 ;
38609 void *argp1 = 0 ;
38610 int res1 = 0 ;
38611 bool temp2 = false ;
38612 PyObject * obj0 = 0 ;
38613 PyObject * obj1 = 0 ;
38614 char * kwnames[] = {
38615 (char *) "self",(char *) "docwriter", NULL
38616 };
38617
38618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38620 if (!SWIG_IsOK(res1)) {
38621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38622 }
38623 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38624 {
38625 arg2 = wxString_in_helper(obj1);
38626 if (arg2 == NULL) SWIG_fail;
38627 temp2 = true;
38628 }
38629 {
38630 PyThreadState* __tstate = wxPyBeginAllowThreads();
38631 (arg1)->AddDocWriter((wxString const &)*arg2);
38632 wxPyEndAllowThreads(__tstate);
38633 if (PyErr_Occurred()) SWIG_fail;
38634 }
38635 resultobj = SWIG_Py_Void();
38636 {
38637 if (temp2)
38638 delete arg2;
38639 }
38640 return resultobj;
38641 fail:
38642 {
38643 if (temp2)
38644 delete arg2;
38645 }
38646 return NULL;
38647 }
38648
38649
38650 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38651 PyObject *resultobj = 0;
38652 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38653 bool result;
38654 void *argp1 = 0 ;
38655 int res1 = 0 ;
38656 PyObject *swig_obj[1] ;
38657
38658 if (!args) SWIG_fail;
38659 swig_obj[0] = args;
38660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38661 if (!SWIG_IsOK(res1)) {
38662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38663 }
38664 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38665 {
38666 PyThreadState* __tstate = wxPyBeginAllowThreads();
38667 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38668 wxPyEndAllowThreads(__tstate);
38669 if (PyErr_Occurred()) SWIG_fail;
38670 }
38671 {
38672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38673 }
38674 return resultobj;
38675 fail:
38676 return NULL;
38677 }
38678
38679
38680 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38681 PyObject *resultobj = 0;
38682 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38683 wxArrayString *result = 0 ;
38684 void *argp1 = 0 ;
38685 int res1 = 0 ;
38686 PyObject *swig_obj[1] ;
38687
38688 if (!args) SWIG_fail;
38689 swig_obj[0] = args;
38690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38691 if (!SWIG_IsOK(res1)) {
38692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38693 }
38694 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38695 {
38696 PyThreadState* __tstate = wxPyBeginAllowThreads();
38697 {
38698 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38699 result = (wxArrayString *) &_result_ref;
38700 }
38701 wxPyEndAllowThreads(__tstate);
38702 if (PyErr_Occurred()) SWIG_fail;
38703 }
38704 {
38705 resultobj = wxArrayString2PyList_helper(*result);
38706 }
38707 return resultobj;
38708 fail:
38709 return NULL;
38710 }
38711
38712
38713 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38714 PyObject *resultobj = 0;
38715 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38716 wxArrayString *arg2 = 0 ;
38717 void *argp1 = 0 ;
38718 int res1 = 0 ;
38719 bool temp2 = false ;
38720 PyObject * obj0 = 0 ;
38721 PyObject * obj1 = 0 ;
38722 char * kwnames[] = {
38723 (char *) "self",(char *) "artists", NULL
38724 };
38725
38726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38728 if (!SWIG_IsOK(res1)) {
38729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38730 }
38731 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38732 {
38733 if (! PySequence_Check(obj1)) {
38734 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38735 SWIG_fail;
38736 }
38737 arg2 = new wxArrayString;
38738 temp2 = true;
38739 int i, len=PySequence_Length(obj1);
38740 for (i=0; i<len; i++) {
38741 PyObject* item = PySequence_GetItem(obj1, i);
38742 wxString* s = wxString_in_helper(item);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 arg2->Add(*s);
38745 delete s;
38746 Py_DECREF(item);
38747 }
38748 }
38749 {
38750 PyThreadState* __tstate = wxPyBeginAllowThreads();
38751 (arg1)->SetArtists((wxArrayString const &)*arg2);
38752 wxPyEndAllowThreads(__tstate);
38753 if (PyErr_Occurred()) SWIG_fail;
38754 }
38755 resultobj = SWIG_Py_Void();
38756 {
38757 if (temp2) delete arg2;
38758 }
38759 return resultobj;
38760 fail:
38761 {
38762 if (temp2) delete arg2;
38763 }
38764 return NULL;
38765 }
38766
38767
38768 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38769 PyObject *resultobj = 0;
38770 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38771 wxString *arg2 = 0 ;
38772 void *argp1 = 0 ;
38773 int res1 = 0 ;
38774 bool temp2 = false ;
38775 PyObject * obj0 = 0 ;
38776 PyObject * obj1 = 0 ;
38777 char * kwnames[] = {
38778 (char *) "self",(char *) "artist", NULL
38779 };
38780
38781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38783 if (!SWIG_IsOK(res1)) {
38784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38785 }
38786 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38787 {
38788 arg2 = wxString_in_helper(obj1);
38789 if (arg2 == NULL) SWIG_fail;
38790 temp2 = true;
38791 }
38792 {
38793 PyThreadState* __tstate = wxPyBeginAllowThreads();
38794 (arg1)->AddArtist((wxString const &)*arg2);
38795 wxPyEndAllowThreads(__tstate);
38796 if (PyErr_Occurred()) SWIG_fail;
38797 }
38798 resultobj = SWIG_Py_Void();
38799 {
38800 if (temp2)
38801 delete arg2;
38802 }
38803 return resultobj;
38804 fail:
38805 {
38806 if (temp2)
38807 delete arg2;
38808 }
38809 return NULL;
38810 }
38811
38812
38813 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38814 PyObject *resultobj = 0;
38815 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38816 bool result;
38817 void *argp1 = 0 ;
38818 int res1 = 0 ;
38819 PyObject *swig_obj[1] ;
38820
38821 if (!args) SWIG_fail;
38822 swig_obj[0] = args;
38823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38824 if (!SWIG_IsOK(res1)) {
38825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38826 }
38827 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38828 {
38829 PyThreadState* __tstate = wxPyBeginAllowThreads();
38830 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38831 wxPyEndAllowThreads(__tstate);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 }
38834 {
38835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38836 }
38837 return resultobj;
38838 fail:
38839 return NULL;
38840 }
38841
38842
38843 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38844 PyObject *resultobj = 0;
38845 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38846 wxArrayString *result = 0 ;
38847 void *argp1 = 0 ;
38848 int res1 = 0 ;
38849 PyObject *swig_obj[1] ;
38850
38851 if (!args) SWIG_fail;
38852 swig_obj[0] = args;
38853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38854 if (!SWIG_IsOK(res1)) {
38855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38856 }
38857 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38858 {
38859 PyThreadState* __tstate = wxPyBeginAllowThreads();
38860 {
38861 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38862 result = (wxArrayString *) &_result_ref;
38863 }
38864 wxPyEndAllowThreads(__tstate);
38865 if (PyErr_Occurred()) SWIG_fail;
38866 }
38867 {
38868 resultobj = wxArrayString2PyList_helper(*result);
38869 }
38870 return resultobj;
38871 fail:
38872 return NULL;
38873 }
38874
38875
38876 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38877 PyObject *resultobj = 0;
38878 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38879 wxArrayString *arg2 = 0 ;
38880 void *argp1 = 0 ;
38881 int res1 = 0 ;
38882 bool temp2 = false ;
38883 PyObject * obj0 = 0 ;
38884 PyObject * obj1 = 0 ;
38885 char * kwnames[] = {
38886 (char *) "self",(char *) "translators", NULL
38887 };
38888
38889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38891 if (!SWIG_IsOK(res1)) {
38892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38893 }
38894 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38895 {
38896 if (! PySequence_Check(obj1)) {
38897 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38898 SWIG_fail;
38899 }
38900 arg2 = new wxArrayString;
38901 temp2 = true;
38902 int i, len=PySequence_Length(obj1);
38903 for (i=0; i<len; i++) {
38904 PyObject* item = PySequence_GetItem(obj1, i);
38905 wxString* s = wxString_in_helper(item);
38906 if (PyErr_Occurred()) SWIG_fail;
38907 arg2->Add(*s);
38908 delete s;
38909 Py_DECREF(item);
38910 }
38911 }
38912 {
38913 PyThreadState* __tstate = wxPyBeginAllowThreads();
38914 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38915 wxPyEndAllowThreads(__tstate);
38916 if (PyErr_Occurred()) SWIG_fail;
38917 }
38918 resultobj = SWIG_Py_Void();
38919 {
38920 if (temp2) delete arg2;
38921 }
38922 return resultobj;
38923 fail:
38924 {
38925 if (temp2) delete arg2;
38926 }
38927 return NULL;
38928 }
38929
38930
38931 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38932 PyObject *resultobj = 0;
38933 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38934 wxString *arg2 = 0 ;
38935 void *argp1 = 0 ;
38936 int res1 = 0 ;
38937 bool temp2 = false ;
38938 PyObject * obj0 = 0 ;
38939 PyObject * obj1 = 0 ;
38940 char * kwnames[] = {
38941 (char *) "self",(char *) "translator", NULL
38942 };
38943
38944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38946 if (!SWIG_IsOK(res1)) {
38947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38948 }
38949 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38950 {
38951 arg2 = wxString_in_helper(obj1);
38952 if (arg2 == NULL) SWIG_fail;
38953 temp2 = true;
38954 }
38955 {
38956 PyThreadState* __tstate = wxPyBeginAllowThreads();
38957 (arg1)->AddTranslator((wxString const &)*arg2);
38958 wxPyEndAllowThreads(__tstate);
38959 if (PyErr_Occurred()) SWIG_fail;
38960 }
38961 resultobj = SWIG_Py_Void();
38962 {
38963 if (temp2)
38964 delete arg2;
38965 }
38966 return resultobj;
38967 fail:
38968 {
38969 if (temp2)
38970 delete arg2;
38971 }
38972 return NULL;
38973 }
38974
38975
38976 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38977 PyObject *resultobj = 0;
38978 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38979 bool result;
38980 void *argp1 = 0 ;
38981 int res1 = 0 ;
38982 PyObject *swig_obj[1] ;
38983
38984 if (!args) SWIG_fail;
38985 swig_obj[0] = args;
38986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38987 if (!SWIG_IsOK(res1)) {
38988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38989 }
38990 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38991 {
38992 PyThreadState* __tstate = wxPyBeginAllowThreads();
38993 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38994 wxPyEndAllowThreads(__tstate);
38995 if (PyErr_Occurred()) SWIG_fail;
38996 }
38997 {
38998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38999 }
39000 return resultobj;
39001 fail:
39002 return NULL;
39003 }
39004
39005
39006 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39007 PyObject *resultobj = 0;
39008 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39009 wxArrayString *result = 0 ;
39010 void *argp1 = 0 ;
39011 int res1 = 0 ;
39012 PyObject *swig_obj[1] ;
39013
39014 if (!args) SWIG_fail;
39015 swig_obj[0] = args;
39016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39017 if (!SWIG_IsOK(res1)) {
39018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39019 }
39020 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39021 {
39022 PyThreadState* __tstate = wxPyBeginAllowThreads();
39023 {
39024 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
39025 result = (wxArrayString *) &_result_ref;
39026 }
39027 wxPyEndAllowThreads(__tstate);
39028 if (PyErr_Occurred()) SWIG_fail;
39029 }
39030 {
39031 resultobj = wxArrayString2PyList_helper(*result);
39032 }
39033 return resultobj;
39034 fail:
39035 return NULL;
39036 }
39037
39038
39039 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39040 PyObject *resultobj = 0;
39041 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39042 bool result;
39043 void *argp1 = 0 ;
39044 int res1 = 0 ;
39045 PyObject *swig_obj[1] ;
39046
39047 if (!args) SWIG_fail;
39048 swig_obj[0] = args;
39049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39050 if (!SWIG_IsOK(res1)) {
39051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39052 }
39053 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39054 {
39055 PyThreadState* __tstate = wxPyBeginAllowThreads();
39056 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39057 wxPyEndAllowThreads(__tstate);
39058 if (PyErr_Occurred()) SWIG_fail;
39059 }
39060 {
39061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39062 }
39063 return resultobj;
39064 fail:
39065 return NULL;
39066 }
39067
39068
39069 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39070 PyObject *resultobj = 0;
39071 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39072 wxString result;
39073 void *argp1 = 0 ;
39074 int res1 = 0 ;
39075 PyObject *swig_obj[1] ;
39076
39077 if (!args) SWIG_fail;
39078 swig_obj[0] = args;
39079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39080 if (!SWIG_IsOK(res1)) {
39081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39082 }
39083 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39084 {
39085 PyThreadState* __tstate = wxPyBeginAllowThreads();
39086 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39087 wxPyEndAllowThreads(__tstate);
39088 if (PyErr_Occurred()) SWIG_fail;
39089 }
39090 {
39091 #if wxUSE_UNICODE
39092 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39093 #else
39094 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39095 #endif
39096 }
39097 return resultobj;
39098 fail:
39099 return NULL;
39100 }
39101
39102
39103 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39104 PyObject *obj;
39105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39106 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39107 return SWIG_Py_Void();
39108 }
39109
39110 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39111 return SWIG_Python_InitShadowInstance(args);
39112 }
39113
39114 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39115 PyObject *resultobj = 0;
39116 wxAboutDialogInfo *arg1 = 0 ;
39117 void *argp1 = 0 ;
39118 int res1 = 0 ;
39119 PyObject * obj0 = 0 ;
39120 char * kwnames[] = {
39121 (char *) "info", NULL
39122 };
39123
39124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39125 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39126 if (!SWIG_IsOK(res1)) {
39127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39128 }
39129 if (!argp1) {
39130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39131 }
39132 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39133 {
39134 PyThreadState* __tstate = wxPyBeginAllowThreads();
39135 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39136 wxPyEndAllowThreads(__tstate);
39137 if (PyErr_Occurred()) SWIG_fail;
39138 }
39139 resultobj = SWIG_Py_Void();
39140 return resultobj;
39141 fail:
39142 return NULL;
39143 }
39144
39145
39146 static PyMethodDef SwigMethods[] = {
39147 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39148 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39149 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39151 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39152 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39153 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39154 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39155 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39156 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39157 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39158 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39159 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39160 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39161 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39162 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39163 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39164 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39165 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39166 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39167 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39168 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39169 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39170 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39171 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39172 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39173 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39174 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39175 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39176 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39177 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39178 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39179 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39180 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39181 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39182 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39183 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39184 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39185 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39186 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39187 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39188 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39189 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39190 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39191 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39192 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39193 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39194 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39196 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39197 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39198 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39199 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39200 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39201 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39202 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39203 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39204 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39205 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39206 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39207 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39208 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39209 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39210 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39211 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39212 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39213 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39214 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39215 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39216 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39217 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39218 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39219 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39220 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39221 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39222 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39223 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39224 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39225 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39228 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39229 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39230 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39231 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39232 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39233 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39234 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39235 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39236 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39237 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39238 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39239 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39241 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39242 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39243 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39244 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39245 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39246 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39247 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39248 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39249 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39250 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39251 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39252 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39253 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39254 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39255 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39256 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39257 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39258 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39259 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39260 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39261 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39263 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39264 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39265 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39267 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39268 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39269 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39270 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39271 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39272 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39273 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39274 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39275 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39276 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39277 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39278 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39279 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39280 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39281 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39282 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39283 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39284 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39285 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39287 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39288 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39289 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39290 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39291 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39292 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39293 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39294 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39295 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39296 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39297 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39298 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39299 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39300 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39301 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39302 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39304 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39305 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39306 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39307 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39308 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39309 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39310 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39312 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39313 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39314 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39315 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39316 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39318 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39319 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39320 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39321 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39322 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39323 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39324 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39325 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39326 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39327 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39328 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39329 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39330 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39331 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39332 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39333 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39334 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39335 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39336 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39337 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39338 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39340 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39341 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39342 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39343 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39344 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39345 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39346 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39347 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39348 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39349 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39350 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39351 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39352 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39354 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39355 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39357 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39358 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39359 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39361 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39362 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39363 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39364 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39365 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39367 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39368 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39369 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39370 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39371 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39372 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39373 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39374 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39375 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39376 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39377 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39378 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39379 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39380 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39381 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39382 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39383 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39384 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39385 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39386 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39387 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39388 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39389 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39390 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39391 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39393 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39394 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39395 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39396 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39397 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39398 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39399 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39400 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39401 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39402 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39404 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39405 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39408 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39410 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39411 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39414 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39415 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39416 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39417 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39418 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39419 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39420 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39421 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39422 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39423 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39424 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39425 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39426 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39427 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39428 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39429 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39430 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39431 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39432 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39433 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39434 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39435 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39436 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39437 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39438 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39439 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39440 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39441 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39442 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39443 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39445 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39446 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39447 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39448 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39449 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39450 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39451 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39452 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39453 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39454 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39456 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39457 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39458 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39459 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39460 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39461 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39462 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39463 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39464 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39465 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39467 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39468 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39469 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39470 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39471 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39472 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39473 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39474 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39475 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39476 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39477 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39478 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39479 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39480 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39481 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39482 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39483 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39484 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39485 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39486 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39487 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39488 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39489 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39490 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39491 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39492 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39493 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39494 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39495 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39496 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39498 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39499 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39500 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39501 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39502 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39503 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39504 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39505 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39506 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39509 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39510 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39511 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39512 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39513 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39514 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39515 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39516 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39517 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39518 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39519 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39520 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39521 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39522 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39523 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39524 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39525 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39526 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39527 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39528 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39529 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39530 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39531 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39532 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39533 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39534 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39535 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39536 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39537 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39538 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39539 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39540 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39541 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39542 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39543 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39544 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39545 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39546 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39547 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39548 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39549 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39550 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39551 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39552 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39553 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39554 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39555 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39556 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39557 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39558 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39559 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39560 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39561 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39562 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39563 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39564 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39565 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39566 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39567 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39568 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39571 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39572 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39573 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39575 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39576 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39577 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39578 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39579 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39580 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39581 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39582 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39583 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39584 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39585 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39586 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39587 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39589 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39590 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39591 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39592 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39593 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39594 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39595 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39596 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39597 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39598 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39599 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39600 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39601 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39602 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39603 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39604 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39605 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39606 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39607 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39608 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39614 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39616 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39617 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39619 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39621 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39623 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39625 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39626 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39627 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39628 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39629 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39630 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39631 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39632 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39633 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39634 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39635 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39636 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39637 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39638 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39639 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39641 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39642 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39643 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39644 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39645 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39646 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39647 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39648 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39649 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39650 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39651 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39652 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39653 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39655 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39662 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39666 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39667 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39668 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39669 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39675 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39676 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39678 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39680 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39681 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39682 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39683 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39687 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39688 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39690 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39691 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39692 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39694 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39695 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39696 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39698 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39699 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39700 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39701 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39704 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39705 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39706 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39707 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39708 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39709 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39715 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39719 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39720 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39721 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39722 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39728 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39729 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39734 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39748 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39749 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39750 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39751 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39758 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39759 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39760 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39761 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39762 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39764 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39765 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39766 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39767 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39768 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39769 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39771 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39773 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39774 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39775 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39777 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39779 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39781 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39783 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39787 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39788 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39792 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39801 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39802 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39803 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39804 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39805 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39809 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39810 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39811 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39812 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39813 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39814 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39816 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39817 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39818 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39819 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39820 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39821 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39822 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39823 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39824 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39825 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39826 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39827 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39828 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39830 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39832 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39833 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39834 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39835 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39836 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39839 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39840 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39841 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39843 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39845 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39851 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39852 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39853 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39854 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39855 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39856 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39857 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39858 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39859 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39860 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39861 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39862 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39863 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39864 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39865 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39866 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39867 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39868 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39869 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39870 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39872 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39874 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39876 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39878 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39880 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39881 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39883 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39884 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39885 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39886 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39887 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39888 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39889 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39891 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39892 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39893 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39894 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39895 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39896 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39898 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39899 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39902 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39903 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39904 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39905 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39906 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39907 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39908 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39909 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39911 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39912 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39913 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39914 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39915 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39916 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39917 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39918 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39919 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39920 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39921 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39922 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39923 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39925 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39927 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39928 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39929 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39930 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39931 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39933 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39934 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39935 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39936 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39937 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39940 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39941 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39942 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39944 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39945 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39946 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39948 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39949 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39950 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39951 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39952 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39954 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39955 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39956 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39957 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39958 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39960 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39961 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39962 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39964 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39965 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39966 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39967 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39969 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39970 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39971 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39972 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39973 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39974 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39975 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39976 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39977 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39978 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39979 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39980 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39981 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39982 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39983 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39984 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39986 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39987 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39988 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39989 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39990 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39991 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39992 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39993 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39994 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39995 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39996 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39998 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39999 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
40000 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40001 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40002 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
40003 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40004 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
40005 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
40006 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
40007 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
40008 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
40009 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
40010 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40011 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
40012 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40013 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40014 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
40015 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40016 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40017 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
40018 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
40019 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
40020 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
40021 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
40022 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
40023 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
40024 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
40025 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
40027 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
40028 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
40029 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
40030 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
40031 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
40032 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
40033 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
40034 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
40035 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
40036 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
40037 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
40038 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
40039 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
40040 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
40042 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
40043 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
40044 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
40045 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
40046 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
40047 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
40048 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
40049 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
40050 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
40051 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
40052 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40053 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40054 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40055 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40056 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40057 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40059 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40060 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40061 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40062 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40063 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40064 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40065 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40066 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40067 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40068 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40069 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40070 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40071 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40072 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40073 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40074 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40075 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40076 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40077 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40078 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40080 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40081 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40082 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40083 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40084 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40085 { (char *)"StandardPaths_GetExecutablePath", (PyCFunction)_wrap_StandardPaths_GetExecutablePath, METH_O, NULL},
40086 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40087 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40088 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40089 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40090 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40091 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40092 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40093 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40094 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40095 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40096 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40097 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40098 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40099 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40100 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40101 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40102 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40103 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40104 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40105 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40106 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40107 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40108 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40109 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40110 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40111 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40112 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40113 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40114 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40115 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40116 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40117 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40118 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40119 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40120 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40121 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40122 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40123 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40124 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40125 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40126 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40127 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40128 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40129 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40130 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40131 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40132 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40133 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40134 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40135 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40136 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40137 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40138 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40139 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40140 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40141 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40142 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40143 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40144 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40145 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40146 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40147 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40148 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40149 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40150 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40151 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40152 { NULL, NULL, 0, NULL }
40153 };
40154
40155
40156 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40157
40158 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40159 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40160 }
40161 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40162 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40163 }
40164 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40165 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40166 }
40167 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40168 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40169 }
40170 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40171 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40172 }
40173 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40174 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40175 }
40176 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40177 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40178 }
40179 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40180 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40181 }
40182 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40183 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40184 }
40185 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40186 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40187 }
40188 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40189 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40190 }
40191 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40192 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40193 }
40194 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40195 return (void *)((wxEvent *) ((wxPyEvent *) x));
40196 }
40197 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40198 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40199 }
40200 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40201 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40202 }
40203 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40204 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40205 }
40206 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40207 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40208 }
40209 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40210 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40211 }
40212 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40213 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40214 }
40215 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40216 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40217 }
40218 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40219 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40220 }
40221 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40222 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40223 }
40224 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40225 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40226 }
40227 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40228 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40229 }
40230 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40231 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40232 }
40233 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40234 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40235 }
40236 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40237 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40238 }
40239 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40240 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40241 }
40242 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40243 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40244 }
40245 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40246 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40247 }
40248 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40249 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40250 }
40251 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40252 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40253 }
40254 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40255 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40256 }
40257 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40258 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40259 }
40260 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40261 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40262 }
40263 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40264 return (void *)((wxEvent *) ((wxShowEvent *) x));
40265 }
40266 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40267 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40268 }
40269 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40270 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40271 }
40272 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40273 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40274 }
40275 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40276 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40277 }
40278 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40279 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40280 }
40281 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40282 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40283 }
40284 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40285 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40286 }
40287 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40288 return (void *)((wxConfigBase *) ((wxConfig *) x));
40289 }
40290 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40291 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40292 }
40293 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40294 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40295 }
40296 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40297 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40298 }
40299 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40300 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40301 }
40302 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40303 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40304 }
40305 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40306 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40307 }
40308 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40309 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40310 }
40311 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40312 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40313 }
40314 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40315 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40316 }
40317 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40318 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40319 }
40320 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40321 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40322 }
40323 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40324 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40325 }
40326 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40327 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40328 }
40329 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40330 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40331 }
40332 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40333 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40334 }
40335 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40336 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40337 }
40338 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40339 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40340 }
40341 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40342 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40343 }
40344 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40345 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40346 }
40347 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40348 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40349 }
40350 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40351 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40352 }
40353 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40354 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40355 }
40356 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40357 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40358 }
40359 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40360 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40361 }
40362 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40363 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40364 }
40365 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40366 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40367 }
40368 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40369 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40370 }
40371 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40372 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40373 }
40374 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40375 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40376 }
40377 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40378 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40379 }
40380 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40381 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40382 }
40383 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40384 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40385 }
40386 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40387 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40388 }
40389 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40390 return (void *)((wxObject *) ((wxSizerItem *) x));
40391 }
40392 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40393 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40394 }
40395 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40396 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40397 }
40398 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40399 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40400 }
40401 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40402 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40403 }
40404 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40405 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40406 }
40407 static void *_p_wxSizerTo_p_wxObject(void *x) {
40408 return (void *)((wxObject *) ((wxSizer *) x));
40409 }
40410 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40411 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40412 }
40413 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40414 return (void *)((wxObject *) ((wxFileHistory *) x));
40415 }
40416 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40417 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40418 }
40419 static void *_p_wxEventTo_p_wxObject(void *x) {
40420 return (void *)((wxObject *) ((wxEvent *) x));
40421 }
40422 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40423 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40424 }
40425 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40426 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40427 }
40428 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40429 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40430 }
40431 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40432 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40433 }
40434 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40435 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40436 }
40437 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40438 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40439 }
40440 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40441 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40442 }
40443 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40444 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40445 }
40446 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40447 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40448 }
40449 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40450 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40451 }
40452 static void *_p_wxControlTo_p_wxObject(void *x) {
40453 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40454 }
40455 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40456 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40457 }
40458 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40459 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40460 }
40461 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40462 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40463 }
40464 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40465 return (void *)((wxObject *) ((wxFSFile *) x));
40466 }
40467 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40468 return (void *)((wxObject *) ((wxClipboard *) x));
40469 }
40470 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40471 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40472 }
40473 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40474 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40475 }
40476 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40477 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40478 }
40479 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40480 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40481 }
40482 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40483 return (void *)((wxObject *) ((wxToolTip *) x));
40484 }
40485 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40486 return (void *)((wxObject *) ((wxMenuItem *) x));
40487 }
40488 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40489 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40490 }
40491 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40492 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40493 }
40494 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40496 }
40497 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40498 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40499 }
40500 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40501 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40502 }
40503 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40504 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40505 }
40506 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40507 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40508 }
40509 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40510 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40511 }
40512 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40513 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40514 }
40515 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40516 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40517 }
40518 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40519 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40520 }
40521 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40522 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40523 }
40524 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40525 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40526 }
40527 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40528 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40529 }
40530 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40531 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40532 }
40533 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40534 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40535 }
40536 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40537 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40538 }
40539 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40540 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40541 }
40542 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40543 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40544 }
40545 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40546 return (void *)((wxObject *) ((wxImageHandler *) x));
40547 }
40548 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40549 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40550 }
40551 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40552 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40553 }
40554 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40555 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40556 }
40557 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40558 return (void *)((wxObject *) ((wxEvtHandler *) x));
40559 }
40560 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40561 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40562 }
40563 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40564 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40565 }
40566 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40567 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40568 }
40569 static void *_p_wxImageTo_p_wxObject(void *x) {
40570 return (void *)((wxObject *) ((wxImage *) x));
40571 }
40572 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40573 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40574 }
40575 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40576 return (void *)((wxObject *) ((wxSystemOptions *) x));
40577 }
40578 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40579 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40580 }
40581 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40582 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40583 }
40584 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40585 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40586 }
40587 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40588 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40589 }
40590 static void *_p_wxWindowTo_p_wxObject(void *x) {
40591 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40592 }
40593 static void *_p_wxMenuTo_p_wxObject(void *x) {
40594 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40595 }
40596 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40597 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40598 }
40599 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40600 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40601 }
40602 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40603 return (void *)((wxObject *) ((wxFileSystem *) x));
40604 }
40605 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40606 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40607 }
40608 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40609 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40610 }
40611 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40612 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40613 }
40614 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40615 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40616 }
40617 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40618 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40619 }
40620 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40621 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40622 }
40623 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40624 return (void *)((wxObject *) ((wxBusyInfo *) x));
40625 }
40626 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40627 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40628 }
40629 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40630 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40631 }
40632 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40633 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40634 }
40635 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40636 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40637 }
40638 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40639 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40640 }
40641 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40642 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40643 }
40644 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40645 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40646 }
40647 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40648 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40649 }
40650 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40651 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40652 }
40653 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40654 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40655 }
40656 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40657 return (void *)((wxLog *) ((wxLogBuffer *) x));
40658 }
40659 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40660 return (void *)((wxLog *) ((wxLogStderr *) x));
40661 }
40662 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40663 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40664 }
40665 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40666 return (void *)((wxLog *) ((wxLogWindow *) x));
40667 }
40668 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40669 return (void *)((wxLog *) ((wxLogChain *) x));
40670 }
40671 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40672 return (void *)((wxLog *) ((wxLogGui *) x));
40673 }
40674 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40675 return (void *)((wxLog *) ((wxPyLog *) x));
40676 }
40677 static void *_p_wxControlTo_p_wxWindow(void *x) {
40678 return (void *)((wxWindow *) ((wxControl *) x));
40679 }
40680 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40681 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40682 }
40683 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40684 return (void *)((wxWindow *) ((wxMenuBar *) x));
40685 }
40686 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40687 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40688 }
40689 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40690 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40691 }
40692 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40693 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};
40694 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40695 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40696 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40697 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40698 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40699 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40700 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40701 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40702 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40703 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40704 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40705 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40706 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40707 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40708 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40709 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40710 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40711 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40712 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40713 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40714 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40715 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40716 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40717 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40727 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40728 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40729 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40730 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40731 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40732 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40733 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40734 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40735 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40736 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40737 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40738 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40739 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40740 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40741 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40742 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40743 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40754 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40765 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40772 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40773 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40779 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40797 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40798 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40799 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40800 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40801 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40802 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40803 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40804 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40805 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40806 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40807 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40808 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40809 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40810 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40811 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40812 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40813 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40814 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40815 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40816 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40817 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40818 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40819 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40820 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40821 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40822 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40823 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40824 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40825 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40826 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40827 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40828 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40829 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40830 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40831 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40832 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40833 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40834 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40835 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40836 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40837 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40838 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40839 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40840 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40841 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40842 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40843 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40844 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40845 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40846 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40847 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40848 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40849 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40850 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40851 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40852 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40853 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40854 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40855 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40856 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40857 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40858 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40859 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40860 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40861 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40862 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40863 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40864 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40865 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40866
40867 static swig_type_info *swig_type_initial[] = {
40868 &_swigt__p_char,
40869 &_swigt__p_form_ops_t,
40870 &_swigt__p_int,
40871 &_swigt__p_unsigned_char,
40872 &_swigt__p_unsigned_int,
40873 &_swigt__p_unsigned_long,
40874 &_swigt__p_void,
40875 &_swigt__p_wxANIHandler,
40876 &_swigt__p_wxAboutDialogInfo,
40877 &_swigt__p_wxAcceleratorTable,
40878 &_swigt__p_wxActivateEvent,
40879 &_swigt__p_wxArrayString,
40880 &_swigt__p_wxBMPHandler,
40881 &_swigt__p_wxBitmap,
40882 &_swigt__p_wxBitmapDataObject,
40883 &_swigt__p_wxBoxSizer,
40884 &_swigt__p_wxBusyCursor,
40885 &_swigt__p_wxBusyInfo,
40886 &_swigt__p_wxCURHandler,
40887 &_swigt__p_wxCaret,
40888 &_swigt__p_wxChar,
40889 &_swigt__p_wxChildFocusEvent,
40890 &_swigt__p_wxClipboard,
40891 &_swigt__p_wxClipboardLocker,
40892 &_swigt__p_wxClipboardTextEvent,
40893 &_swigt__p_wxCloseEvent,
40894 &_swigt__p_wxColour,
40895 &_swigt__p_wxCommandEvent,
40896 &_swigt__p_wxConfig,
40897 &_swigt__p_wxConfigBase,
40898 &_swigt__p_wxConfigPathChanger,
40899 &_swigt__p_wxContextMenuEvent,
40900 &_swigt__p_wxControl,
40901 &_swigt__p_wxControlWithItems,
40902 &_swigt__p_wxCursor,
40903 &_swigt__p_wxCustomDataObject,
40904 &_swigt__p_wxDC,
40905 &_swigt__p_wxDataFormat,
40906 &_swigt__p_wxDataObject,
40907 &_swigt__p_wxDataObjectComposite,
40908 &_swigt__p_wxDataObjectSimple,
40909 &_swigt__p_wxDateEvent,
40910 &_swigt__p_wxDateSpan,
40911 &_swigt__p_wxDateTime,
40912 &_swigt__p_wxDateTime__TimeZone,
40913 &_swigt__p_wxDisplay,
40914 &_swigt__p_wxDisplayChangedEvent,
40915 &_swigt__p_wxDropFilesEvent,
40916 &_swigt__p_wxDuplexMode,
40917 &_swigt__p_wxEraseEvent,
40918 &_swigt__p_wxEvent,
40919 &_swigt__p_wxEvtHandler,
40920 &_swigt__p_wxFSFile,
40921 &_swigt__p_wxFileConfig,
40922 &_swigt__p_wxFileDataObject,
40923 &_swigt__p_wxFileHistory,
40924 &_swigt__p_wxFileSystem,
40925 &_swigt__p_wxFileType,
40926 &_swigt__p_wxFileTypeInfo,
40927 &_swigt__p_wxFlexGridSizer,
40928 &_swigt__p_wxFocusEvent,
40929 &_swigt__p_wxFont,
40930 &_swigt__p_wxFrame,
40931 &_swigt__p_wxGBSizerItem,
40932 &_swigt__p_wxGIFHandler,
40933 &_swigt__p_wxGridBagSizer,
40934 &_swigt__p_wxGridSizer,
40935 &_swigt__p_wxICOHandler,
40936 &_swigt__p_wxIcon,
40937 &_swigt__p_wxIconizeEvent,
40938 &_swigt__p_wxIdleEvent,
40939 &_swigt__p_wxImage,
40940 &_swigt__p_wxImageHandler,
40941 &_swigt__p_wxIndividualLayoutConstraint,
40942 &_swigt__p_wxInitDialogEvent,
40943 &_swigt__p_wxJPEGHandler,
40944 &_swigt__p_wxJoystick,
40945 &_swigt__p_wxJoystickEvent,
40946 &_swigt__p_wxKeyEvent,
40947 &_swigt__p_wxKillError,
40948 &_swigt__p_wxLayoutConstraints,
40949 &_swigt__p_wxLog,
40950 &_swigt__p_wxLogBuffer,
40951 &_swigt__p_wxLogChain,
40952 &_swigt__p_wxLogGui,
40953 &_swigt__p_wxLogNull,
40954 &_swigt__p_wxLogStderr,
40955 &_swigt__p_wxLogTextCtrl,
40956 &_swigt__p_wxLogWindow,
40957 &_swigt__p_wxMaximizeEvent,
40958 &_swigt__p_wxMenu,
40959 &_swigt__p_wxMenuBar,
40960 &_swigt__p_wxMenuEvent,
40961 &_swigt__p_wxMenuItem,
40962 &_swigt__p_wxMetafileDataObject,
40963 &_swigt__p_wxMimeTypesManager,
40964 &_swigt__p_wxMouseCaptureChangedEvent,
40965 &_swigt__p_wxMouseCaptureLostEvent,
40966 &_swigt__p_wxMouseEvent,
40967 &_swigt__p_wxMouseState,
40968 &_swigt__p_wxMoveEvent,
40969 &_swigt__p_wxMutexGuiLocker,
40970 &_swigt__p_wxNavigationKeyEvent,
40971 &_swigt__p_wxNcPaintEvent,
40972 &_swigt__p_wxNotifyEvent,
40973 &_swigt__p_wxObject,
40974 &_swigt__p_wxOutputStream,
40975 &_swigt__p_wxPCXHandler,
40976 &_swigt__p_wxPNGHandler,
40977 &_swigt__p_wxPNMHandler,
40978 &_swigt__p_wxPaintEvent,
40979 &_swigt__p_wxPaletteChangedEvent,
40980 &_swigt__p_wxPaperSize,
40981 &_swigt__p_wxPlatformInfo,
40982 &_swigt__p_wxPoint,
40983 &_swigt__p_wxPowerEvent,
40984 &_swigt__p_wxProcessEvent,
40985 &_swigt__p_wxPyApp,
40986 &_swigt__p_wxPyArtProvider,
40987 &_swigt__p_wxPyBitmapDataObject,
40988 &_swigt__p_wxPyCommandEvent,
40989 &_swigt__p_wxPyDataObjectSimple,
40990 &_swigt__p_wxPyDropSource,
40991 &_swigt__p_wxPyDropTarget,
40992 &_swigt__p_wxPyEvent,
40993 &_swigt__p_wxPyFileDropTarget,
40994 &_swigt__p_wxPyImageHandler,
40995 &_swigt__p_wxPyLog,
40996 &_swigt__p_wxPyProcess,
40997 &_swigt__p_wxPySizer,
40998 &_swigt__p_wxPyTextDataObject,
40999 &_swigt__p_wxPyTextDropTarget,
41000 &_swigt__p_wxPyTimer,
41001 &_swigt__p_wxPyTipProvider,
41002 &_swigt__p_wxPyValidator,
41003 &_swigt__p_wxQueryNewPaletteEvent,
41004 &_swigt__p_wxRect,
41005 &_swigt__p_wxScrollEvent,
41006 &_swigt__p_wxScrollWinEvent,
41007 &_swigt__p_wxSetCursorEvent,
41008 &_swigt__p_wxShowEvent,
41009 &_swigt__p_wxSingleInstanceChecker,
41010 &_swigt__p_wxSize,
41011 &_swigt__p_wxSizeEvent,
41012 &_swigt__p_wxSizer,
41013 &_swigt__p_wxSizerItem,
41014 &_swigt__p_wxSound,
41015 &_swigt__p_wxStandardPaths,
41016 &_swigt__p_wxStaticBoxSizer,
41017 &_swigt__p_wxStdDialogButtonSizer,
41018 &_swigt__p_wxStopWatch,
41019 &_swigt__p_wxString,
41020 &_swigt__p_wxSysColourChangedEvent,
41021 &_swigt__p_wxSystemOptions,
41022 &_swigt__p_wxSystemSettings,
41023 &_swigt__p_wxTGAHandler,
41024 &_swigt__p_wxTIFFHandler,
41025 &_swigt__p_wxTextCtrl,
41026 &_swigt__p_wxTextDataObject,
41027 &_swigt__p_wxTimeSpan,
41028 &_swigt__p_wxTimer,
41029 &_swigt__p_wxTimerEvent,
41030 &_swigt__p_wxTimerRunner,
41031 &_swigt__p_wxTipProvider,
41032 &_swigt__p_wxToolTip,
41033 &_swigt__p_wxURLDataObject,
41034 &_swigt__p_wxUpdateUIEvent,
41035 &_swigt__p_wxValidator,
41036 &_swigt__p_wxVideoMode,
41037 &_swigt__p_wxWindow,
41038 &_swigt__p_wxWindowCreateEvent,
41039 &_swigt__p_wxWindowDestroyEvent,
41040 &_swigt__p_wxWindowDisabler,
41041 &_swigt__p_wxXPMHandler,
41042 };
41043
41044 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
41045 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
41046 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
41047 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
41048 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
41052 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
41053 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41054 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}};
41055 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41061 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41063 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}};
41064 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41069 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}};
41070 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41071 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}};
41072 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41073 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41115 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}};
41116 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41125 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41134 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}};
41135 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41164 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41165 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41166 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41167 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41168 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41169 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41170 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41171 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41172 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41173 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41174 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41175 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41176 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41177 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41178 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_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_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}};
41179 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41180 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41181 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41182 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41183 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41184 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41185 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41186 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41187 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41188 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41189 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}};
41190 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41191 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41192 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41193 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41194 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41195 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41196 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41197 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41198 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41199 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41200 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41201 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41202 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41203 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41204 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41205 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41206 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41207 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}};
41208 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41209 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41210 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41211 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41212 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}};
41213 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41214 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41215 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41216 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}};
41217 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41218
41219 static swig_cast_info *swig_cast_initial[] = {
41220 _swigc__p_char,
41221 _swigc__p_form_ops_t,
41222 _swigc__p_int,
41223 _swigc__p_unsigned_char,
41224 _swigc__p_unsigned_int,
41225 _swigc__p_unsigned_long,
41226 _swigc__p_void,
41227 _swigc__p_wxANIHandler,
41228 _swigc__p_wxAboutDialogInfo,
41229 _swigc__p_wxAcceleratorTable,
41230 _swigc__p_wxActivateEvent,
41231 _swigc__p_wxArrayString,
41232 _swigc__p_wxBMPHandler,
41233 _swigc__p_wxBitmap,
41234 _swigc__p_wxBitmapDataObject,
41235 _swigc__p_wxBoxSizer,
41236 _swigc__p_wxBusyCursor,
41237 _swigc__p_wxBusyInfo,
41238 _swigc__p_wxCURHandler,
41239 _swigc__p_wxCaret,
41240 _swigc__p_wxChar,
41241 _swigc__p_wxChildFocusEvent,
41242 _swigc__p_wxClipboard,
41243 _swigc__p_wxClipboardLocker,
41244 _swigc__p_wxClipboardTextEvent,
41245 _swigc__p_wxCloseEvent,
41246 _swigc__p_wxColour,
41247 _swigc__p_wxCommandEvent,
41248 _swigc__p_wxConfig,
41249 _swigc__p_wxConfigBase,
41250 _swigc__p_wxConfigPathChanger,
41251 _swigc__p_wxContextMenuEvent,
41252 _swigc__p_wxControl,
41253 _swigc__p_wxControlWithItems,
41254 _swigc__p_wxCursor,
41255 _swigc__p_wxCustomDataObject,
41256 _swigc__p_wxDC,
41257 _swigc__p_wxDataFormat,
41258 _swigc__p_wxDataObject,
41259 _swigc__p_wxDataObjectComposite,
41260 _swigc__p_wxDataObjectSimple,
41261 _swigc__p_wxDateEvent,
41262 _swigc__p_wxDateSpan,
41263 _swigc__p_wxDateTime,
41264 _swigc__p_wxDateTime__TimeZone,
41265 _swigc__p_wxDisplay,
41266 _swigc__p_wxDisplayChangedEvent,
41267 _swigc__p_wxDropFilesEvent,
41268 _swigc__p_wxDuplexMode,
41269 _swigc__p_wxEraseEvent,
41270 _swigc__p_wxEvent,
41271 _swigc__p_wxEvtHandler,
41272 _swigc__p_wxFSFile,
41273 _swigc__p_wxFileConfig,
41274 _swigc__p_wxFileDataObject,
41275 _swigc__p_wxFileHistory,
41276 _swigc__p_wxFileSystem,
41277 _swigc__p_wxFileType,
41278 _swigc__p_wxFileTypeInfo,
41279 _swigc__p_wxFlexGridSizer,
41280 _swigc__p_wxFocusEvent,
41281 _swigc__p_wxFont,
41282 _swigc__p_wxFrame,
41283 _swigc__p_wxGBSizerItem,
41284 _swigc__p_wxGIFHandler,
41285 _swigc__p_wxGridBagSizer,
41286 _swigc__p_wxGridSizer,
41287 _swigc__p_wxICOHandler,
41288 _swigc__p_wxIcon,
41289 _swigc__p_wxIconizeEvent,
41290 _swigc__p_wxIdleEvent,
41291 _swigc__p_wxImage,
41292 _swigc__p_wxImageHandler,
41293 _swigc__p_wxIndividualLayoutConstraint,
41294 _swigc__p_wxInitDialogEvent,
41295 _swigc__p_wxJPEGHandler,
41296 _swigc__p_wxJoystick,
41297 _swigc__p_wxJoystickEvent,
41298 _swigc__p_wxKeyEvent,
41299 _swigc__p_wxKillError,
41300 _swigc__p_wxLayoutConstraints,
41301 _swigc__p_wxLog,
41302 _swigc__p_wxLogBuffer,
41303 _swigc__p_wxLogChain,
41304 _swigc__p_wxLogGui,
41305 _swigc__p_wxLogNull,
41306 _swigc__p_wxLogStderr,
41307 _swigc__p_wxLogTextCtrl,
41308 _swigc__p_wxLogWindow,
41309 _swigc__p_wxMaximizeEvent,
41310 _swigc__p_wxMenu,
41311 _swigc__p_wxMenuBar,
41312 _swigc__p_wxMenuEvent,
41313 _swigc__p_wxMenuItem,
41314 _swigc__p_wxMetafileDataObject,
41315 _swigc__p_wxMimeTypesManager,
41316 _swigc__p_wxMouseCaptureChangedEvent,
41317 _swigc__p_wxMouseCaptureLostEvent,
41318 _swigc__p_wxMouseEvent,
41319 _swigc__p_wxMouseState,
41320 _swigc__p_wxMoveEvent,
41321 _swigc__p_wxMutexGuiLocker,
41322 _swigc__p_wxNavigationKeyEvent,
41323 _swigc__p_wxNcPaintEvent,
41324 _swigc__p_wxNotifyEvent,
41325 _swigc__p_wxObject,
41326 _swigc__p_wxOutputStream,
41327 _swigc__p_wxPCXHandler,
41328 _swigc__p_wxPNGHandler,
41329 _swigc__p_wxPNMHandler,
41330 _swigc__p_wxPaintEvent,
41331 _swigc__p_wxPaletteChangedEvent,
41332 _swigc__p_wxPaperSize,
41333 _swigc__p_wxPlatformInfo,
41334 _swigc__p_wxPoint,
41335 _swigc__p_wxPowerEvent,
41336 _swigc__p_wxProcessEvent,
41337 _swigc__p_wxPyApp,
41338 _swigc__p_wxPyArtProvider,
41339 _swigc__p_wxPyBitmapDataObject,
41340 _swigc__p_wxPyCommandEvent,
41341 _swigc__p_wxPyDataObjectSimple,
41342 _swigc__p_wxPyDropSource,
41343 _swigc__p_wxPyDropTarget,
41344 _swigc__p_wxPyEvent,
41345 _swigc__p_wxPyFileDropTarget,
41346 _swigc__p_wxPyImageHandler,
41347 _swigc__p_wxPyLog,
41348 _swigc__p_wxPyProcess,
41349 _swigc__p_wxPySizer,
41350 _swigc__p_wxPyTextDataObject,
41351 _swigc__p_wxPyTextDropTarget,
41352 _swigc__p_wxPyTimer,
41353 _swigc__p_wxPyTipProvider,
41354 _swigc__p_wxPyValidator,
41355 _swigc__p_wxQueryNewPaletteEvent,
41356 _swigc__p_wxRect,
41357 _swigc__p_wxScrollEvent,
41358 _swigc__p_wxScrollWinEvent,
41359 _swigc__p_wxSetCursorEvent,
41360 _swigc__p_wxShowEvent,
41361 _swigc__p_wxSingleInstanceChecker,
41362 _swigc__p_wxSize,
41363 _swigc__p_wxSizeEvent,
41364 _swigc__p_wxSizer,
41365 _swigc__p_wxSizerItem,
41366 _swigc__p_wxSound,
41367 _swigc__p_wxStandardPaths,
41368 _swigc__p_wxStaticBoxSizer,
41369 _swigc__p_wxStdDialogButtonSizer,
41370 _swigc__p_wxStopWatch,
41371 _swigc__p_wxString,
41372 _swigc__p_wxSysColourChangedEvent,
41373 _swigc__p_wxSystemOptions,
41374 _swigc__p_wxSystemSettings,
41375 _swigc__p_wxTGAHandler,
41376 _swigc__p_wxTIFFHandler,
41377 _swigc__p_wxTextCtrl,
41378 _swigc__p_wxTextDataObject,
41379 _swigc__p_wxTimeSpan,
41380 _swigc__p_wxTimer,
41381 _swigc__p_wxTimerEvent,
41382 _swigc__p_wxTimerRunner,
41383 _swigc__p_wxTipProvider,
41384 _swigc__p_wxToolTip,
41385 _swigc__p_wxURLDataObject,
41386 _swigc__p_wxUpdateUIEvent,
41387 _swigc__p_wxValidator,
41388 _swigc__p_wxVideoMode,
41389 _swigc__p_wxWindow,
41390 _swigc__p_wxWindowCreateEvent,
41391 _swigc__p_wxWindowDestroyEvent,
41392 _swigc__p_wxWindowDisabler,
41393 _swigc__p_wxXPMHandler,
41394 };
41395
41396
41397 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41398
41399 static swig_const_info swig_const_table[] = {
41400 {0, 0, 0, 0.0, 0, 0}};
41401
41402 #ifdef __cplusplus
41403 }
41404 #endif
41405 /* -----------------------------------------------------------------------------
41406 * Type initialization:
41407 * This problem is tough by the requirement that no dynamic
41408 * memory is used. Also, since swig_type_info structures store pointers to
41409 * swig_cast_info structures and swig_cast_info structures store pointers back
41410 * to swig_type_info structures, we need some lookup code at initialization.
41411 * The idea is that swig generates all the structures that are needed.
41412 * The runtime then collects these partially filled structures.
41413 * The SWIG_InitializeModule function takes these initial arrays out of
41414 * swig_module, and does all the lookup, filling in the swig_module.types
41415 * array with the correct data and linking the correct swig_cast_info
41416 * structures together.
41417 *
41418 * The generated swig_type_info structures are assigned staticly to an initial
41419 * array. We just loop though that array, and handle each type individually.
41420 * First we lookup if this type has been already loaded, and if so, use the
41421 * loaded structure instead of the generated one. Then we have to fill in the
41422 * cast linked list. The cast data is initially stored in something like a
41423 * two-dimensional array. Each row corresponds to a type (there are the same
41424 * number of rows as there are in the swig_type_initial array). Each entry in
41425 * a column is one of the swig_cast_info structures for that type.
41426 * The cast_initial array is actually an array of arrays, because each row has
41427 * a variable number of columns. So to actually build the cast linked list,
41428 * we find the array of casts associated with the type, and loop through it
41429 * adding the casts to the list. The one last trick we need to do is making
41430 * sure the type pointer in the swig_cast_info struct is correct.
41431 *
41432 * First off, we lookup the cast->type name to see if it is already loaded.
41433 * There are three cases to handle:
41434 * 1) If the cast->type has already been loaded AND the type we are adding
41435 * casting info to has not been loaded (it is in this module), THEN we
41436 * replace the cast->type pointer with the type pointer that has already
41437 * been loaded.
41438 * 2) If BOTH types (the one we are adding casting info to, and the
41439 * cast->type) are loaded, THEN the cast info has already been loaded by
41440 * the previous module so we just ignore it.
41441 * 3) Finally, if cast->type has not already been loaded, then we add that
41442 * swig_cast_info to the linked list (because the cast->type) pointer will
41443 * be correct.
41444 * ----------------------------------------------------------------------------- */
41445
41446 #ifdef __cplusplus
41447 extern "C" {
41448 #if 0
41449 } /* c-mode */
41450 #endif
41451 #endif
41452
41453 #if 0
41454 #define SWIGRUNTIME_DEBUG
41455 #endif
41456
41457 SWIGRUNTIME void
41458 SWIG_InitializeModule(void *clientdata) {
41459 size_t i;
41460 swig_module_info *module_head;
41461 static int init_run = 0;
41462
41463 clientdata = clientdata;
41464
41465 if (init_run) return;
41466 init_run = 1;
41467
41468 /* Initialize the swig_module */
41469 swig_module.type_initial = swig_type_initial;
41470 swig_module.cast_initial = swig_cast_initial;
41471
41472 /* Try and load any already created modules */
41473 module_head = SWIG_GetModule(clientdata);
41474 if (module_head) {
41475 swig_module.next = module_head->next;
41476 module_head->next = &swig_module;
41477 } else {
41478 /* This is the first module loaded */
41479 swig_module.next = &swig_module;
41480 SWIG_SetModule(clientdata, &swig_module);
41481 }
41482
41483 /* Now work on filling in swig_module.types */
41484 #ifdef SWIGRUNTIME_DEBUG
41485 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41486 #endif
41487 for (i = 0; i < swig_module.size; ++i) {
41488 swig_type_info *type = 0;
41489 swig_type_info *ret;
41490 swig_cast_info *cast;
41491
41492 #ifdef SWIGRUNTIME_DEBUG
41493 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41494 #endif
41495
41496 /* if there is another module already loaded */
41497 if (swig_module.next != &swig_module) {
41498 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41499 }
41500 if (type) {
41501 /* Overwrite clientdata field */
41502 #ifdef SWIGRUNTIME_DEBUG
41503 printf("SWIG_InitializeModule: found type %s\n", type->name);
41504 #endif
41505 if (swig_module.type_initial[i]->clientdata) {
41506 type->clientdata = swig_module.type_initial[i]->clientdata;
41507 #ifdef SWIGRUNTIME_DEBUG
41508 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41509 #endif
41510 }
41511 } else {
41512 type = swig_module.type_initial[i];
41513 }
41514
41515 /* Insert casting types */
41516 cast = swig_module.cast_initial[i];
41517 while (cast->type) {
41518 /* Don't need to add information already in the list */
41519 ret = 0;
41520 #ifdef SWIGRUNTIME_DEBUG
41521 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41522 #endif
41523 if (swig_module.next != &swig_module) {
41524 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41525 #ifdef SWIGRUNTIME_DEBUG
41526 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41527 #endif
41528 }
41529 if (ret) {
41530 if (type == swig_module.type_initial[i]) {
41531 #ifdef SWIGRUNTIME_DEBUG
41532 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41533 #endif
41534 cast->type = ret;
41535 ret = 0;
41536 } else {
41537 /* Check for casting already in the list */
41538 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41539 #ifdef SWIGRUNTIME_DEBUG
41540 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41541 #endif
41542 if (!ocast) ret = 0;
41543 }
41544 }
41545
41546 if (!ret) {
41547 #ifdef SWIGRUNTIME_DEBUG
41548 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41549 #endif
41550 if (type->cast) {
41551 type->cast->prev = cast;
41552 cast->next = type->cast;
41553 }
41554 type->cast = cast;
41555 }
41556 cast++;
41557 }
41558 /* Set entry in modules->types array equal to the type */
41559 swig_module.types[i] = type;
41560 }
41561 swig_module.types[i] = 0;
41562
41563 #ifdef SWIGRUNTIME_DEBUG
41564 printf("**** SWIG_InitializeModule: Cast List ******\n");
41565 for (i = 0; i < swig_module.size; ++i) {
41566 int j = 0;
41567 swig_cast_info *cast = swig_module.cast_initial[i];
41568 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41569 while (cast->type) {
41570 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41571 cast++;
41572 ++j;
41573 }
41574 printf("---- Total casts: %d\n",j);
41575 }
41576 printf("**** SWIG_InitializeModule: Cast List ******\n");
41577 #endif
41578 }
41579
41580 /* This function will propagate the clientdata field of type to
41581 * any new swig_type_info structures that have been added into the list
41582 * of equivalent types. It is like calling
41583 * SWIG_TypeClientData(type, clientdata) a second time.
41584 */
41585 SWIGRUNTIME void
41586 SWIG_PropagateClientData(void) {
41587 size_t i;
41588 swig_cast_info *equiv;
41589 static int init_run = 0;
41590
41591 if (init_run) return;
41592 init_run = 1;
41593
41594 for (i = 0; i < swig_module.size; i++) {
41595 if (swig_module.types[i]->clientdata) {
41596 equiv = swig_module.types[i]->cast;
41597 while (equiv) {
41598 if (!equiv->converter) {
41599 if (equiv->type && !equiv->type->clientdata)
41600 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41601 }
41602 equiv = equiv->next;
41603 }
41604 }
41605 }
41606 }
41607
41608 #ifdef __cplusplus
41609 #if 0
41610 {
41611 /* c-mode */
41612 #endif
41613 }
41614 #endif
41615
41616
41617
41618 #ifdef __cplusplus
41619 extern "C" {
41620 #endif
41621
41622 /* Python-specific SWIG API */
41623 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41624 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41625 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41626
41627 /* -----------------------------------------------------------------------------
41628 * global variable support code.
41629 * ----------------------------------------------------------------------------- */
41630
41631 typedef struct swig_globalvar {
41632 char *name; /* Name of global variable */
41633 PyObject *(*get_attr)(void); /* Return the current value */
41634 int (*set_attr)(PyObject *); /* Set the value */
41635 struct swig_globalvar *next;
41636 } swig_globalvar;
41637
41638 typedef struct swig_varlinkobject {
41639 PyObject_HEAD
41640 swig_globalvar *vars;
41641 } swig_varlinkobject;
41642
41643 SWIGINTERN PyObject *
41644 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41645 return PyString_FromString("<Swig global variables>");
41646 }
41647
41648 SWIGINTERN PyObject *
41649 swig_varlink_str(swig_varlinkobject *v) {
41650 PyObject *str = PyString_FromString("(");
41651 swig_globalvar *var;
41652 for (var = v->vars; var; var=var->next) {
41653 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41654 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41655 }
41656 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41657 return str;
41658 }
41659
41660 SWIGINTERN int
41661 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41662 PyObject *str = swig_varlink_str(v);
41663 fprintf(fp,"Swig global variables ");
41664 fprintf(fp,"%s\n", PyString_AsString(str));
41665 Py_DECREF(str);
41666 return 0;
41667 }
41668
41669 SWIGINTERN void
41670 swig_varlink_dealloc(swig_varlinkobject *v) {
41671 swig_globalvar *var = v->vars;
41672 while (var) {
41673 swig_globalvar *n = var->next;
41674 free(var->name);
41675 free(var);
41676 var = n;
41677 }
41678 }
41679
41680 SWIGINTERN PyObject *
41681 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41682 PyObject *res = NULL;
41683 swig_globalvar *var = v->vars;
41684 while (var) {
41685 if (strcmp(var->name,n) == 0) {
41686 res = (*var->get_attr)();
41687 break;
41688 }
41689 var = var->next;
41690 }
41691 if (res == NULL && !PyErr_Occurred()) {
41692 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41693 }
41694 return res;
41695 }
41696
41697 SWIGINTERN int
41698 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41699 int res = 1;
41700 swig_globalvar *var = v->vars;
41701 while (var) {
41702 if (strcmp(var->name,n) == 0) {
41703 res = (*var->set_attr)(p);
41704 break;
41705 }
41706 var = var->next;
41707 }
41708 if (res == 1 && !PyErr_Occurred()) {
41709 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41710 }
41711 return res;
41712 }
41713
41714 SWIGINTERN PyTypeObject*
41715 swig_varlink_type(void) {
41716 static char varlink__doc__[] = "Swig var link object";
41717 static PyTypeObject varlink_type;
41718 static int type_init = 0;
41719 if (!type_init) {
41720 const PyTypeObject tmp
41721 = {
41722 PyObject_HEAD_INIT(NULL)
41723 0, /* Number of items in variable part (ob_size) */
41724 (char *)"swigvarlink", /* Type name (tp_name) */
41725 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41726 0, /* Itemsize (tp_itemsize) */
41727 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41728 (printfunc) swig_varlink_print, /* Print (tp_print) */
41729 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41730 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41731 0, /* tp_compare */
41732 (reprfunc) swig_varlink_repr, /* tp_repr */
41733 0, /* tp_as_number */
41734 0, /* tp_as_sequence */
41735 0, /* tp_as_mapping */
41736 0, /* tp_hash */
41737 0, /* tp_call */
41738 (reprfunc)swig_varlink_str, /* tp_str */
41739 0, /* tp_getattro */
41740 0, /* tp_setattro */
41741 0, /* tp_as_buffer */
41742 0, /* tp_flags */
41743 varlink__doc__, /* tp_doc */
41744 0, /* tp_traverse */
41745 0, /* tp_clear */
41746 0, /* tp_richcompare */
41747 0, /* tp_weaklistoffset */
41748 #if PY_VERSION_HEX >= 0x02020000
41749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41750 #endif
41751 #if PY_VERSION_HEX >= 0x02030000
41752 0, /* tp_del */
41753 #endif
41754 #ifdef COUNT_ALLOCS
41755 0,0,0,0 /* tp_alloc -> tp_next */
41756 #endif
41757 };
41758 varlink_type = tmp;
41759 varlink_type.ob_type = &PyType_Type;
41760 type_init = 1;
41761 }
41762 return &varlink_type;
41763 }
41764
41765 /* Create a variable linking object for use later */
41766 SWIGINTERN PyObject *
41767 SWIG_Python_newvarlink(void) {
41768 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41769 if (result) {
41770 result->vars = 0;
41771 }
41772 return ((PyObject*) result);
41773 }
41774
41775 SWIGINTERN void
41776 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41777 swig_varlinkobject *v = (swig_varlinkobject *) p;
41778 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41779 if (gv) {
41780 size_t size = strlen(name)+1;
41781 gv->name = (char *)malloc(size);
41782 if (gv->name) {
41783 strncpy(gv->name,name,size);
41784 gv->get_attr = get_attr;
41785 gv->set_attr = set_attr;
41786 gv->next = v->vars;
41787 }
41788 }
41789 v->vars = gv;
41790 }
41791
41792 SWIGINTERN PyObject *
41793 SWIG_globals() {
41794 static PyObject *_SWIG_globals = 0;
41795 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41796 return _SWIG_globals;
41797 }
41798
41799 /* -----------------------------------------------------------------------------
41800 * constants/methods manipulation
41801 * ----------------------------------------------------------------------------- */
41802
41803 /* Install Constants */
41804 SWIGINTERN void
41805 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41806 PyObject *obj = 0;
41807 size_t i;
41808 for (i = 0; constants[i].type; ++i) {
41809 switch(constants[i].type) {
41810 case SWIG_PY_POINTER:
41811 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41812 break;
41813 case SWIG_PY_BINARY:
41814 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41815 break;
41816 default:
41817 obj = 0;
41818 break;
41819 }
41820 if (obj) {
41821 PyDict_SetItemString(d, constants[i].name, obj);
41822 Py_DECREF(obj);
41823 }
41824 }
41825 }
41826
41827 /* -----------------------------------------------------------------------------*/
41828 /* Fix SwigMethods to carry the callback ptrs when needed */
41829 /* -----------------------------------------------------------------------------*/
41830
41831 SWIGINTERN void
41832 SWIG_Python_FixMethods(PyMethodDef *methods,
41833 swig_const_info *const_table,
41834 swig_type_info **types,
41835 swig_type_info **types_initial) {
41836 size_t i;
41837 for (i = 0; methods[i].ml_name; ++i) {
41838 const char *c = methods[i].ml_doc;
41839 if (c && (c = strstr(c, "swig_ptr: "))) {
41840 int j;
41841 swig_const_info *ci = 0;
41842 const char *name = c + 10;
41843 for (j = 0; const_table[j].type; ++j) {
41844 if (strncmp(const_table[j].name, name,
41845 strlen(const_table[j].name)) == 0) {
41846 ci = &(const_table[j]);
41847 break;
41848 }
41849 }
41850 if (ci) {
41851 size_t shift = (ci->ptype) - types;
41852 swig_type_info *ty = types_initial[shift];
41853 size_t ldoc = (c - methods[i].ml_doc);
41854 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41855 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41856 if (ndoc) {
41857 char *buff = ndoc;
41858 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41859 if (ptr) {
41860 strncpy(buff, methods[i].ml_doc, ldoc);
41861 buff += ldoc;
41862 strncpy(buff, "swig_ptr: ", 10);
41863 buff += 10;
41864 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41865 methods[i].ml_doc = ndoc;
41866 }
41867 }
41868 }
41869 }
41870 }
41871 }
41872
41873 #ifdef __cplusplus
41874 }
41875 #endif
41876
41877 /* -----------------------------------------------------------------------------*
41878 * Partial Init method
41879 * -----------------------------------------------------------------------------*/
41880
41881 #ifdef __cplusplus
41882 extern "C"
41883 #endif
41884 SWIGEXPORT void SWIG_init(void) {
41885 PyObject *m, *d;
41886
41887 /* Fix SwigMethods to carry the callback ptrs when needed */
41888 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41889
41890 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41891 d = PyModule_GetDict(m);
41892
41893 SWIG_InitializeModule(0);
41894 SWIG_InstallConstants(d,swig_const_table);
41895
41896
41897 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41898 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41899 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41900 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41901 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41902 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41903 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41904 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41905 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41906 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41907 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41908 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41909 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41910 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41911 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41912 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41913 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41914 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41915 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41916 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41917 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41918 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41919 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41920 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41921 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41922 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41923 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41924 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41925 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41926 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41927 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41928 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41929 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41930 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41931 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41932 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41933 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41934 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41935 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41936 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41937 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41938 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41939 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41940 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41941 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41942 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41943 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41944 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41945 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41946 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41947 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41948 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41949 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41950 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41951 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41952 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41953 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41954 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41955 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41956 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41957 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41958 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41959 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41960 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41961 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41962 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41963 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41964 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41965 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41966 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41967 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41968 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41969 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41970 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41971 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41972 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41973 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41974 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41975 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41976 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41977 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41978 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41979 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41980 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41981 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41982 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41983 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41984 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41985 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41986 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41987 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41988 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41989 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41990 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41991 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41992 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41993 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41994 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41995 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41996 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41997 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41998 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41999 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
42000 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
42001 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
42002 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
42003 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
42004 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
42005 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
42006 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
42007 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
42008 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
42009 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
42010 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
42011 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
42012 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
42013 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
42014 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
42015 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
42016 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
42017 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
42018 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
42019 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
42020 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
42021 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
42022 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
42023 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
42024 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
42025 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
42026 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
42027 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
42028 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
42029 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
42030 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
42031 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
42032 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
42033 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
42034 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
42035 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
42036 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
42037 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
42038 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
42039 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
42040 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
42041 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
42042 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
42043 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
42044 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
42045
42046 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
42047
42048 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
42049 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
42050 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
42051 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
42052 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
42053 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42054 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42055 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42056 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42057 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42058 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42059 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42060 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42061 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42062 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42063 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42064 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42065 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42066 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42067 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42068 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42069 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42070 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42071 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42072 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42073 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42074 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42075 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42076 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42077 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42078 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42079 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42080 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42081 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42082 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42083 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42084 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42085 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42086 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42087 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42088 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42089 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42090 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42091 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42092 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42093 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42094 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42095 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42096 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42097 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42098 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42099 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42100 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42101
42102 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42103
42104 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42105 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42106 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42107 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42108 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42109 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42110 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42111 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42112 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42113 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42114 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42115 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42116 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42117 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42118 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42119 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42120 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42121 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42122 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42123 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42125 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42126 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42127 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42128 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42129 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42130 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42131 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42132 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42133 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42134 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42135 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42180
42181 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42182
42183 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42184 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42185 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42186 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42187 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42188 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42189 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42190 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42191 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42192 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42193 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42194 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42195 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42196 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42197 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42198 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42199 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42200 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42201 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42202 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42203 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42204 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42205 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42206 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42207 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42208 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42209 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42210 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42211 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42212 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42213 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42214 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42215 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42216 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42217 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42218 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42219 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42220 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42221 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42222 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42223 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42224 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42225 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42226 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42227 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42228 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42229 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42230 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42231 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42232 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42233 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42234 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42235 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42236 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42237 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42238 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42239 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42240 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42241 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42242 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42243 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42244 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42245 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42246 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42247 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42248 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42249 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42250 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42251 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42252 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42253 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42254 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42255 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42256 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42257 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42258 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42259 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42260 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42261 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42262 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42263 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42264 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42265 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42266 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42267 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42268 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42269 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42270 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42271 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42272 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42273 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42274 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42275 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42276 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42277 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42278 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42279 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42280 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42281 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42282 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42283 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42284 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42285 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42286 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42287 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42288 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42289 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42290 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42291 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42292 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42293 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42294 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42295 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42296 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42297 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42298 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42299 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42300 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42301 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42302 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42303 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42304 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42305 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42306 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42307 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42308 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42309 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42310 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42311 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42312 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42313 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42314 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42315 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42316 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42317 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42318 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42319 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42320 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42321 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42322 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42323 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42324 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42325 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42326 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42327 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42328 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42329 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42330 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42331 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42332 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42333 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42334 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42335 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42336 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42337 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42338 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42339 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42340 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42341 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42342 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42343 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42344 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42345 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42346 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42347 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42348 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42349 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42350 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42351 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42352 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42353 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42354 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42355 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42356 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42357 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42358 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42359 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42360 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42361 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42362 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42363 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42364 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42365 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42366 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42367 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42368 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42369 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42370 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42371 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42372 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42373 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42374 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42375 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42376 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42377 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42378 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42379 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42380 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42381 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42382 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42383 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42384 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42385 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42386
42387 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42388 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42389 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42390 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42391
42392 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42393 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42394 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42395 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42396 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42397 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42398 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42399 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42400 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42401 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42402 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42403 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42404 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42405 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42406 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42407 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42408 }
42409
wxWidgets (Impactor)