]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
test for mac theme brush
[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
3021 SWIGINTERN swig_type_info*
3022 SWIG_pchar_descriptor()
3023 {
3024 static int init = 0;
3025 static swig_type_info* info = 0;
3026 if (!init) {
3027 info = SWIG_TypeQuery("_p_char");
3028 init = 1;
3029 }
3030 return info;
3031 }
3032
3033
3034 SWIGINTERNINLINE PyObject *
3035 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3036 {
3037 if (carray) {
3038 if (size > INT_MAX) {
3039 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3040 return pchar_descriptor ?
3041 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3042 } else {
3043 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3044 }
3045 } else {
3046 return SWIG_Py_Void();
3047 }
3048 }
3049
3050
3051 SWIGINTERNINLINE PyObject *
3052 SWIG_FromCharPtr(const char *cptr)
3053 {
3054 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3055 }
3056
3057
3058 SWIGINTERN int
3059 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3060 {
3061 unsigned long v;
3062 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3063 if (SWIG_IsOK(res)) {
3064 if ((v > UINT_MAX)) {
3065 return SWIG_OverflowError;
3066 } else {
3067 if (val) *val = static_cast< unsigned int >(v);
3068 }
3069 }
3070 return res;
3071 }
3072
3073 SWIGINTERN wxString wxLog_TimeStamp(){
3074 wxString msg;
3075 wxLog::TimeStamp(&msg);
3076 return msg;
3077 }
3078 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3079 // Make some wrappers that double any % signs so they are 'escaped'
3080 void wxPyLogFatalError(const wxString& msg)
3081 {
3082 wxString m(msg);
3083 m.Replace(wxT("%"), wxT("%%"));
3084 wxLogFatalError(m);
3085 }
3086
3087 void wxPyLogError(const wxString& msg)
3088 {
3089 wxString m(msg);
3090 m.Replace(wxT("%"), wxT("%%"));
3091 wxLogError(m);
3092 }
3093
3094 void wxPyLogWarning(const wxString& msg)
3095 {
3096 wxString m(msg);
3097 m.Replace(wxT("%"), wxT("%%"));
3098 wxLogWarning(m);
3099 }
3100
3101 void wxPyLogMessage(const wxString& msg)
3102 {
3103 wxString m(msg);
3104 m.Replace(wxT("%"), wxT("%%"));
3105 wxLogMessage(m);
3106 }
3107
3108 void wxPyLogInfo(const wxString& msg)
3109 {
3110 wxString m(msg);
3111 m.Replace(wxT("%"), wxT("%%"));
3112 wxLogInfo(m);
3113 }
3114
3115 void wxPyLogDebug(const wxString& msg)
3116 {
3117 wxString m(msg);
3118 m.Replace(wxT("%"), wxT("%%"));
3119 wxLogDebug(m);
3120 }
3121
3122 void wxPyLogVerbose(const wxString& msg)
3123 {
3124 wxString m(msg);
3125 m.Replace(wxT("%"), wxT("%%"));
3126 wxLogVerbose(m);
3127 }
3128
3129 void wxPyLogStatus(const wxString& msg)
3130 {
3131 wxString m(msg);
3132 m.Replace(wxT("%"), wxT("%%"));
3133 wxLogStatus(m);
3134 }
3135
3136 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3137 {
3138 wxString m(msg);
3139 m.Replace(wxT("%"), wxT("%%"));
3140 wxLogStatus(pFrame, m);
3141 }
3142
3143 void wxPyLogSysError(const wxString& msg)
3144 {
3145 wxString m(msg);
3146 m.Replace(wxT("%"), wxT("%%"));
3147 wxLogSysError(m);
3148 }
3149
3150 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3151 {
3152 wxString m(msg);
3153 m.Replace(wxT("%"), wxT("%%"));
3154 wxLogGeneric(level, m);
3155 }
3156
3157 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3158 {
3159 wxString m(msg);
3160 m.Replace(wxT("%"), wxT("%%"));
3161 wxLogTrace(mask, m);
3162 }
3163
3164 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3165 {
3166 wxString m(msg);
3167 m.Replace(wxT("%"), wxT("%%"));
3168 wxLogTrace(mask, m);
3169 }
3170
3171
3172
3173 // A wxLog class that can be derived from in wxPython
3174 class wxPyLog : public wxLog {
3175 public:
3176 wxPyLog() : wxLog() {}
3177
3178 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3179 bool found;
3180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3181 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3182 PyObject* s = wx2PyString(szString);
3183 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3184 Py_DECREF(s);
3185 }
3186 wxPyEndBlockThreads(blocked);
3187 if (! found)
3188 wxLog::DoLog(level, szString, t);
3189 }
3190
3191 virtual void DoLogString(const wxChar *szString, time_t t) {
3192 bool found;
3193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3194 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3195 PyObject* s = wx2PyString(szString);
3196 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3197 Py_DECREF(s);
3198 }
3199 wxPyEndBlockThreads(blocked);
3200 if (! found)
3201 wxLog::DoLogString(szString, t);
3202 }
3203
3204 DEC_PYCALLBACK_VOID_(Flush);
3205 PYPRIVATE;
3206 };
3207 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3208
3209
3210
3211
3212 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3213
3214
3215 #include <wx/joystick.h>
3216
3217
3218 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3219 // A C++ stub class for wxJoystick for platforms that don't have it.
3220 class wxJoystick : public wxObject {
3221 public:
3222 wxJoystick(int joystick = wxJOYSTICK1) {
3223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3224 PyErr_SetString(PyExc_NotImplementedError,
3225 "wxJoystick is not available on this platform.");
3226 wxPyEndBlockThreads(blocked);
3227 }
3228 wxPoint GetPosition() { return wxPoint(-1,-1); }
3229 int GetZPosition() { return -1; }
3230 int GetButtonState() { return -1; }
3231 int GetPOVPosition() { return -1; }
3232 int GetPOVCTSPosition() { return -1; }
3233 int GetRudderPosition() { return -1; }
3234 int GetUPosition() { return -1; }
3235 int GetVPosition() { return -1; }
3236 int GetMovementThreshold() { return -1; }
3237 void SetMovementThreshold(int threshold) {}
3238
3239 bool IsOk(void) { return false; }
3240 int GetNumberJoysticks() { return -1; }
3241 int GetManufacturerId() { return -1; }
3242 int GetProductId() { return -1; }
3243 wxString GetProductName() { return wxEmptyString; }
3244 int GetXMin() { return -1; }
3245 int GetYMin() { return -1; }
3246 int GetZMin() { return -1; }
3247 int GetXMax() { return -1; }
3248 int GetYMax() { return -1; }
3249 int GetZMax() { return -1; }
3250 int GetNumberButtons() { return -1; }
3251 int GetNumberAxes() { return -1; }
3252 int GetMaxButtons() { return -1; }
3253 int GetMaxAxes() { return -1; }
3254 int GetPollingMin() { return -1; }
3255 int GetPollingMax() { return -1; }
3256 int GetRudderMin() { return -1; }
3257 int GetRudderMax() { return -1; }
3258 int GetUMin() { return -1; }
3259 int GetUMax() { return -1; }
3260 int GetVMin() { return -1; }
3261 int GetVMax() { return -1; }
3262
3263 bool HasRudder() { return false; }
3264 bool HasZ() { return false; }
3265 bool HasU() { return false; }
3266 bool HasV() { return false; }
3267 bool HasPOV() { return false; }
3268 bool HasPOV4Dir() { return false; }
3269 bool HasPOVCTS() { return false; }
3270
3271 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3272 bool ReleaseCapture() { return false; }
3273 };
3274 #endif
3275
3276
3277 #include <wx/sound.h>
3278
3279
3280 #if !wxUSE_SOUND
3281 // A C++ stub class for wxWave for platforms that don't have it.
3282 class wxSound : public wxObject
3283 {
3284 public:
3285 wxSound() {
3286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3287 PyErr_SetString(PyExc_NotImplementedError,
3288 "wxSound is not available on this platform.");
3289 wxPyEndBlockThreads(blocked);
3290 }
3291 wxSound(const wxString&/*, bool*/) {
3292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3293 PyErr_SetString(PyExc_NotImplementedError,
3294 "wxSound is not available on this platform.");
3295 wxPyEndBlockThreads(blocked);
3296 }
3297 wxSound(int, const wxByte*) {
3298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3299 PyErr_SetString(PyExc_NotImplementedError,
3300 "wxSound is not available on this platform.");
3301 wxPyEndBlockThreads(blocked);
3302 }
3303
3304 ~wxSound() {};
3305
3306 bool Create(const wxString&/*, bool*/) { return false; }
3307 bool Create(int, const wxByte*) { return false; };
3308 bool IsOk() { return false; };
3309 bool Play(unsigned) const { return false; }
3310 static bool Play(const wxString&, unsigned) { return false; }
3311 static void Stop() {}
3312 };
3313
3314 #endif
3315
3316 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3317 if (fileName.Length() == 0)
3318 return new wxSound;
3319 else
3320 return new wxSound(fileName);
3321 }
3322 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3323 unsigned char* buffer; int size;
3324 wxSound *sound = NULL;
3325
3326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3327 if (!PyArg_Parse(data, "t#", &buffer, &size))
3328 goto done;
3329 sound = new wxSound(size, buffer);
3330 done:
3331 wxPyEndBlockThreads(blocked);
3332 return sound;
3333 }
3334 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3335 #ifndef __WXMAC__
3336 unsigned char* buffer;
3337 int size;
3338 bool rv = false;
3339
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 if (!PyArg_Parse(data, "t#", &buffer, &size))
3342 goto done;
3343 rv = self->Create(size, buffer);
3344 done:
3345 wxPyEndBlockThreads(blocked);
3346 return rv;
3347 #else
3348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3349 PyErr_SetString(PyExc_NotImplementedError,
3350 "Create from data is not available on this platform.");
3351 wxPyEndBlockThreads(blocked);
3352 return false;
3353 #endif
3354 }
3355
3356 #include <wx/mimetype.h>
3357
3358 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3359 wxString str;
3360 if (self->GetMimeType(&str))
3361 return wx2PyString(str);
3362 else
3363 RETURN_NONE();
3364 }
3365 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3366 wxArrayString arr;
3367 if (self->GetMimeTypes(arr))
3368 return wxArrayString2PyList_helper(arr);
3369 else
3370 RETURN_NONE();
3371 }
3372 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3373 wxArrayString arr;
3374 if (self->GetExtensions(arr))
3375 return wxArrayString2PyList_helper(arr);
3376 else
3377 RETURN_NONE();
3378 }
3379 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3380 wxIconLocation loc;
3381 if (self->GetIcon(&loc))
3382 return new wxIcon(loc);
3383 else
3384 return NULL;
3385 }
3386 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3387 wxIconLocation loc;
3388 if (self->GetIcon(&loc)) {
3389 wxString iconFile = loc.GetFileName();
3390 int iconIndex = -1;
3391
3392
3393
3394 // Make a tuple and put the values in it
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 PyObject* tuple = PyTuple_New(3);
3397 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3398 wxT("wxIcon"), true));
3399 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3400 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3401 wxPyEndBlockThreads(blocked);
3402 return tuple;
3403 }
3404 else
3405 RETURN_NONE();
3406 }
3407 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3408 wxString str;
3409 if (self->GetDescription(&str))
3410 return wx2PyString(str);
3411 else
3412 RETURN_NONE();
3413 }
3414 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3415 wxString str;
3416 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3417 return wx2PyString(str);
3418 else
3419 RETURN_NONE();
3420 }
3421 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3422 wxString str;
3423 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3424 return wx2PyString(str);
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 wxArrayString verbs;
3430 wxArrayString commands;
3431 if (self->GetAllCommands(&verbs, &commands,
3432 wxFileType::MessageParameters(filename, mimetype))) {
3433 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3434 PyObject* tuple = PyTuple_New(2);
3435 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3436 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3437 wxPyEndBlockThreads(blocked);
3438 return tuple;
3439 }
3440 else
3441 RETURN_NONE();
3442 }
3443 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3444 return wxFileType::ExpandCommand(command,
3445 wxFileType::MessageParameters(filename, mimetype));
3446 }
3447 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3448 wxArrayString arr;
3449 self->EnumAllFileTypes(arr);
3450 return wxArrayString2PyList_helper(arr);
3451 }
3452
3453 #include <wx/artprov.h>
3454
3455 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3456 static const wxString wxPyART_MENU(wxART_MENU);
3457 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3458 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3459 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3460 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3461 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3462 static const wxString wxPyART_OTHER(wxART_OTHER);
3463 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3464 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3465 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3466 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3467 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3468 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3469 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3470 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3471 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3472 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3473 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3474 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3475 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3476 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3477 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3478 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3479 static const wxString wxPyART_PRINT(wxART_PRINT);
3480 static const wxString wxPyART_HELP(wxART_HELP);
3481 static const wxString wxPyART_TIP(wxART_TIP);
3482 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3483 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3484 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3485 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3486 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3487 static const wxString wxPyART_CDROM(wxART_CDROM);
3488 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3489 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3490 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3491 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3492 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3493 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3494 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3495 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3496 static const wxString wxPyART_ERROR(wxART_ERROR);
3497 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3498 static const wxString wxPyART_WARNING(wxART_WARNING);
3499 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3500 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3501 static const wxString wxPyART_COPY(wxART_COPY);
3502 static const wxString wxPyART_CUT(wxART_CUT);
3503 static const wxString wxPyART_PASTE(wxART_PASTE);
3504 static const wxString wxPyART_DELETE(wxART_DELETE);
3505 static const wxString wxPyART_NEW(wxART_NEW);
3506 static const wxString wxPyART_UNDO(wxART_UNDO);
3507 static const wxString wxPyART_REDO(wxART_REDO);
3508 static const wxString wxPyART_QUIT(wxART_QUIT);
3509 static const wxString wxPyART_FIND(wxART_FIND);
3510 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3511 // Python aware wxArtProvider
3512 class wxPyArtProvider : public wxArtProvider {
3513 public:
3514
3515 virtual wxBitmap CreateBitmap(const wxArtID& id,
3516 const wxArtClient& client,
3517 const wxSize& size) {
3518 wxBitmap rval = wxNullBitmap;
3519 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3520 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3521 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3522 PyObject* ro;
3523 wxBitmap* ptr;
3524 PyObject* s1, *s2;
3525 s1 = wx2PyString(id);
3526 s2 = wx2PyString(client);
3527 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3528 Py_DECREF(so);
3529 Py_DECREF(s1);
3530 Py_DECREF(s2);
3531 if (ro) {
3532 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3533 rval = *ptr;
3534 Py_DECREF(ro);
3535 }
3536 }
3537 wxPyEndBlockThreads(blocked);
3538 return rval;
3539 }
3540
3541 PYPRIVATE;
3542 };
3543
3544 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3545
3546
3547
3548 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3549 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3550 PyObject* ret = PyTuple_New(3);
3551 if (ret) {
3552 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3553 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3554 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3555 }
3556 wxPyEndBlockThreads(blocked);
3557 return ret;
3558 }
3559
3560 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3561 bool cont;
3562 long index = 0;
3563 wxString value;
3564
3565 cont = self->GetFirstGroup(value, index);
3566 return __EnumerationHelper(cont, value, index);
3567 }
3568 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3569 bool cont;
3570 wxString value;
3571
3572 cont = self->GetNextGroup(value, index);
3573 return __EnumerationHelper(cont, value, index);
3574 }
3575 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3576 bool cont;
3577 long index = 0;
3578 wxString value;
3579
3580 cont = self->GetFirstEntry(value, index);
3581 return __EnumerationHelper(cont, value, index);
3582 }
3583 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3584 bool cont;
3585 wxString value;
3586
3587 cont = self->GetNextEntry(value, index);
3588 return __EnumerationHelper(cont, value, index);
3589 }
3590 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3591 long rv;
3592 self->Read(key, &rv, defaultVal);
3593 return rv;
3594 }
3595
3596 SWIGINTERN int
3597 SWIG_AsVal_double (PyObject *obj, double* val)
3598 {
3599 if (PyNumber_Check(obj)) {
3600 if (val) *val = PyFloat_AsDouble(obj);
3601 return SWIG_OK;
3602 }
3603 return SWIG_TypeError;
3604 }
3605
3606 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3607 double rv;
3608 self->Read(key, &rv, defaultVal);
3609 return rv;
3610 }
3611
3612 #define SWIG_From_double PyFloat_FromDouble
3613
3614 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3615 bool rv;
3616 self->Read(key, &rv, defaultVal);
3617 return rv;
3618 }
3619
3620 #include <wx/datetime.h>
3621
3622 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3623 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3624
3625 #define LOCAL_TZ wxDateTime::Local
3626
3627 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3628 wxString am;
3629 wxString pm;
3630 wxDateTime::GetAmPmStrings(&am, &pm);
3631 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3632 PyObject* tup = PyTuple_New(2);
3633 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3634 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3635 wxPyEndBlockThreads(blocked);
3636 return tup;
3637 }
3638
3639 SWIGINTERNINLINE PyObject *
3640 SWIG_From_unsigned_SS_int (unsigned int value)
3641 {
3642 return SWIG_From_unsigned_SS_long (value);
3643 }
3644
3645 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3646 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3647 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3648 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3649 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3650 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3651 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3652 return (*self < *other);
3653 }
3654 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3655 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3656 return (*self <= *other);
3657 }
3658 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3659 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3660 return (*self > *other);
3661 }
3662 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3663 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3664 return (*self >= *other);
3665 }
3666 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3667 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3668 return (*self == *other);
3669 }
3670 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3671 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3672 return (*self != *other);
3673 }
3674 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3675 const wxChar* rv;
3676 const wxChar* _date = date;
3677 rv = self->ParseRfc822Date(_date);
3678 if (rv == NULL) return -1;
3679 return rv - _date;
3680 }
3681 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3682 const wxChar* rv;
3683 const wxChar* _date = date;
3684 rv = self->ParseFormat(_date, format, dateDef);
3685 if (rv == NULL) return -1;
3686 return rv - _date;
3687 }
3688 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3689 const wxChar* rv;
3690 const wxChar* _datetime = datetime;
3691 rv = self->ParseDateTime(_datetime);
3692 if (rv == NULL) return -1;
3693 return rv - _datetime;
3694 }
3695 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3696 const wxChar* rv;
3697 const wxChar* _date = date;
3698 rv = self->ParseDate(_date);
3699 if (rv == NULL) return -1;
3700 return rv - _date;
3701 }
3702 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3703 const wxChar* rv;
3704 const wxChar* _time = time;
3705 rv = self->ParseTime(_time);
3706 if (rv == NULL) return -1;
3707 return rv - _time;
3708 }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3710 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3711 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3712 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3713 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3714 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3716 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3717 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3718 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3719 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3720 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3721 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3722 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3723 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3724 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3725
3726 #include <wx/dataobj.h>
3727
3728 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3729 size_t count = self->GetFormatCount(dir);
3730 wxDataFormat* formats = new wxDataFormat[count];
3731 self->GetAllFormats(formats, dir);
3732
3733 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3734 PyObject* list = PyList_New(count);
3735 for (size_t i=0; i<count; i++) {
3736 wxDataFormat* format = new wxDataFormat(formats[i]);
3737 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3738 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3739 }
3740 wxPyEndBlockThreads(blocked);
3741 delete [] formats;
3742 return list;
3743 }
3744 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3745 PyObject* rval = NULL;
3746 size_t size = self->GetDataSize(format);
3747 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3748 if (size) {
3749 char* buf = new char[size];
3750 if (self->GetDataHere(format, buf))
3751 rval = PyString_FromStringAndSize(buf, size);
3752 delete [] buf;
3753 }
3754 if (! rval) {
3755 rval = Py_None;
3756 Py_INCREF(rval);
3757 }
3758 wxPyEndBlockThreads(blocked);
3759 return rval;
3760 }
3761 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3762 bool rval;
3763 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3764 if (PyString_Check(data)) {
3765 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3766 }
3767 else {
3768 // raise a TypeError if not a string
3769 PyErr_SetString(PyExc_TypeError, "String expected.");
3770 rval = false;
3771 }
3772 wxPyEndBlockThreads(blocked);
3773 return rval;
3774 }
3775 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3776 PyObject* rval = NULL;
3777 size_t size = self->GetDataSize();
3778 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3779 if (size) {
3780 char* buf = new char[size];
3781 if (self->GetDataHere(buf))
3782 rval = PyString_FromStringAndSize(buf, size);
3783 delete [] buf;
3784 }
3785 if (! rval) {
3786 rval = Py_None;
3787 Py_INCREF(rval);
3788 }
3789 wxPyEndBlockThreads(blocked);
3790 return rval;
3791 }
3792 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3793 bool rval;
3794 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3795 if (PyString_Check(data)) {
3796 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3797 }
3798 else {
3799 // raise a TypeError if not a string
3800 PyErr_SetString(PyExc_TypeError, "String expected.");
3801 rval = false;
3802 }
3803 wxPyEndBlockThreads(blocked);
3804 return rval;
3805 }
3806 // Create a new class for wxPython to use
3807 class wxPyDataObjectSimple : public wxDataObjectSimple {
3808 public:
3809 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3810 : wxDataObjectSimple(format) {}
3811
3812 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3813 bool GetDataHere(void *buf) const;
3814 bool SetData(size_t len, const void *buf);
3815 PYPRIVATE;
3816 };
3817
3818 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3819
3820 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3821 // We need to get the data for this object and write it to buf. I think
3822 // the best way to do this for wxPython is to have the Python method
3823 // return either a string or None and then act appropriately with the
3824 // C++ version.
3825
3826 bool rval = false;
3827 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3828 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3829 PyObject* ro;
3830 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3831 if (ro) {
3832 rval = (ro != Py_None && PyString_Check(ro));
3833 if (rval)
3834 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3835 Py_DECREF(ro);
3836 }
3837 }
3838 wxPyEndBlockThreads(blocked);
3839 return rval;
3840 }
3841
3842 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3843 // For this one we simply need to make a string from buf and len
3844 // and send it to the Python method.
3845 bool rval = false;
3846 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3847 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3848 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3849 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3850 Py_DECREF(data);
3851 }
3852 wxPyEndBlockThreads(blocked);
3853 return rval;
3854 }
3855
3856 // Create a new class for wxPython to use
3857 class wxPyTextDataObject : public wxTextDataObject {
3858 public:
3859 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3860 : wxTextDataObject(text) {}
3861
3862 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3863 DEC_PYCALLBACK_STRING__const(GetText);
3864 DEC_PYCALLBACK__STRING(SetText);
3865 PYPRIVATE;
3866 };
3867
3868 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3869 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3870 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3871
3872
3873 // Create a new class for wxPython to use
3874 class wxPyBitmapDataObject : public wxBitmapDataObject {
3875 public:
3876 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3877 : wxBitmapDataObject(bitmap) {}
3878
3879 wxBitmap GetBitmap() const;
3880 void SetBitmap(const wxBitmap& bitmap);
3881 PYPRIVATE;
3882 };
3883
3884 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3885 wxBitmap* rval = &wxNullBitmap;
3886 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3887 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3888 PyObject* ro;
3889 wxBitmap* ptr;
3890 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3891 if (ro) {
3892 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3893 rval = ptr;
3894 Py_DECREF(ro);
3895 }
3896 }
3897 wxPyEndBlockThreads(blocked);
3898 return *rval;
3899 }
3900
3901 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3902 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3903 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3904 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3905 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3906 Py_DECREF(bo);
3907 }
3908 wxPyEndBlockThreads(blocked);
3909 }
3910
3911 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3912 return new wxCustomDataObject(wxDataFormat(formatName));
3913 }
3914 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3915 bool rval;
3916 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3917 if (PyString_Check(data)) {
3918 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3919 }
3920 else {
3921 // raise a TypeError if not a string
3922 PyErr_SetString(PyExc_TypeError, "String expected.");
3923 rval = false;
3924 }
3925 wxPyEndBlockThreads(blocked);
3926 return rval;
3927 }
3928 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3929 PyObject* obj;
3930 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3931 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3932 wxPyEndBlockThreads(blocked);
3933 return obj;
3934 }
3935
3936 class wxMetafileDataObject : public wxDataObjectSimple
3937 {
3938 public:
3939 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3940 };
3941
3942
3943 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3944
3945
3946 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3947 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3948 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3949 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3950 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3951
3952
3953 class wxPyTextDropTarget : public wxTextDropTarget {
3954 public:
3955 wxPyTextDropTarget() {}
3956
3957 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3958
3959 DEC_PYCALLBACK__(OnLeave);
3960 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3961 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3962 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3963 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3964
3965 PYPRIVATE;
3966 };
3967
3968 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3969 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3970 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3971 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3972 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3973 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3974
3975
3976
3977 class wxPyFileDropTarget : public wxFileDropTarget {
3978 public:
3979 wxPyFileDropTarget() {}
3980
3981 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3982
3983 DEC_PYCALLBACK__(OnLeave);
3984 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3985 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3986 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3987 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3988
3989 PYPRIVATE;
3990 };
3991
3992 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3993 const wxArrayString& filenames) {
3994 bool rval = false;
3995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3996 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3997 PyObject* list = wxArrayString2PyList_helper(filenames);
3998 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3999 Py_DECREF(list);
4000 }
4001 wxPyEndBlockThreads(blocked);
4002 return rval;
4003 }
4004
4005
4006
4007 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4008 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4009 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4010 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4011 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4012
4013
4014
4015
4016 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4017
4018 #include <wx/display.h>
4019 #include <wx/vidmode.h>
4020
4021 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4022 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4023
4024 #if !wxUSE_DISPLAY
4025 const wxVideoMode wxDefaultVideoMode;
4026 #endif
4027
4028 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4029 #if wxUSE_DISPLAY
4030 PyObject* pyList = NULL;
4031 wxArrayVideoModes arr = self->GetModes(mode);
4032 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4033 pyList = PyList_New(0);
4034 for (size_t i=0; i < arr.GetCount(); i++)
4035 {
4036 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4037 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4038 PyList_Append(pyList, pyObj);
4039 Py_DECREF(pyObj);
4040 }
4041 wxPyEndBlockThreads(blocked);
4042 return pyList;
4043 #else
4044 wxPyRaiseNotImplemented();
4045 return NULL;
4046 #endif
4047 }
4048 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4049 #if wxUSE_DISPLAY
4050 return self->GetCurrentMode();
4051 #else
4052 wxPyRaiseNotImplemented();
4053 return wxDefaultVideoMode;
4054 #endif
4055 }
4056 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4057 #if wxUSE_DISPLAY
4058 return self->ChangeMode(mode);
4059 #else
4060 wxPyRaiseNotImplemented();
4061 return false;
4062 #endif
4063 }
4064 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4065 #if wxUSE_DISPLAY
4066 self->ResetMode();
4067 #else
4068 wxPyRaiseNotImplemented();
4069 #endif
4070 }
4071
4072 #include <wx/stdpaths.h>
4073
4074 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4075 return (wxStandardPaths*) &wxStandardPaths::Get();
4076 }
4077
4078 #ifndef wxHAS_POWER_EVENTS
4079 // Dummy class and other definitions for platforms that don't have them
4080
4081 // See wxPython_int.h for wxPowerEvent
4082
4083 enum {
4084 wxEVT_POWER_SUSPENDING,
4085 wxEVT_POWER_SUSPENDED,
4086 wxEVT_POWER_SUSPEND_CANCEL,
4087 wxEVT_POWER_RESUME,
4088 };
4089
4090 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4091 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4092
4093 #endif
4094
4095
4096 #include <wx/aboutdlg.h>
4097
4098 #ifdef __cplusplus
4099 extern "C" {
4100 #endif
4101 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4102 PyObject *resultobj = 0;
4103 wxSystemColour arg1 ;
4104 wxColour result;
4105 int val1 ;
4106 int ecode1 = 0 ;
4107 PyObject * obj0 = 0 ;
4108 char * kwnames[] = {
4109 (char *) "index", NULL
4110 };
4111
4112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4113 ecode1 = SWIG_AsVal_int(obj0, &val1);
4114 if (!SWIG_IsOK(ecode1)) {
4115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4116 }
4117 arg1 = static_cast< wxSystemColour >(val1);
4118 {
4119 if (!wxPyCheckForApp()) SWIG_fail;
4120 PyThreadState* __tstate = wxPyBeginAllowThreads();
4121 result = wxSystemSettings::GetColour(arg1);
4122 wxPyEndAllowThreads(__tstate);
4123 if (PyErr_Occurred()) SWIG_fail;
4124 }
4125 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj = 0;
4134 wxSystemFont arg1 ;
4135 wxFont result;
4136 int val1 ;
4137 int ecode1 = 0 ;
4138 PyObject * obj0 = 0 ;
4139 char * kwnames[] = {
4140 (char *) "index", NULL
4141 };
4142
4143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4144 ecode1 = SWIG_AsVal_int(obj0, &val1);
4145 if (!SWIG_IsOK(ecode1)) {
4146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4147 }
4148 arg1 = static_cast< wxSystemFont >(val1);
4149 {
4150 if (!wxPyCheckForApp()) SWIG_fail;
4151 PyThreadState* __tstate = wxPyBeginAllowThreads();
4152 result = wxSystemSettings::GetFont(arg1);
4153 wxPyEndAllowThreads(__tstate);
4154 if (PyErr_Occurred()) SWIG_fail;
4155 }
4156 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4157 return resultobj;
4158 fail:
4159 return NULL;
4160 }
4161
4162
4163 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4164 PyObject *resultobj = 0;
4165 wxSystemMetric arg1 ;
4166 wxWindow *arg2 = (wxWindow *) NULL ;
4167 int result;
4168 int val1 ;
4169 int ecode1 = 0 ;
4170 void *argp2 = 0 ;
4171 int res2 = 0 ;
4172 PyObject * obj0 = 0 ;
4173 PyObject * obj1 = 0 ;
4174 char * kwnames[] = {
4175 (char *) "index",(char *) "win", NULL
4176 };
4177
4178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4179 ecode1 = SWIG_AsVal_int(obj0, &val1);
4180 if (!SWIG_IsOK(ecode1)) {
4181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4182 }
4183 arg1 = static_cast< wxSystemMetric >(val1);
4184 if (obj1) {
4185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4186 if (!SWIG_IsOK(res2)) {
4187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4188 }
4189 arg2 = reinterpret_cast< wxWindow * >(argp2);
4190 }
4191 {
4192 if (!wxPyCheckForApp()) SWIG_fail;
4193 PyThreadState* __tstate = wxPyBeginAllowThreads();
4194 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4195 wxPyEndAllowThreads(__tstate);
4196 if (PyErr_Occurred()) SWIG_fail;
4197 }
4198 resultobj = SWIG_From_int(static_cast< int >(result));
4199 return resultobj;
4200 fail:
4201 return NULL;
4202 }
4203
4204
4205 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4206 PyObject *resultobj = 0;
4207 wxSystemFeature arg1 ;
4208 bool result;
4209 int val1 ;
4210 int ecode1 = 0 ;
4211 PyObject * obj0 = 0 ;
4212 char * kwnames[] = {
4213 (char *) "index", NULL
4214 };
4215
4216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4217 ecode1 = SWIG_AsVal_int(obj0, &val1);
4218 if (!SWIG_IsOK(ecode1)) {
4219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4220 }
4221 arg1 = static_cast< wxSystemFeature >(val1);
4222 {
4223 if (!wxPyCheckForApp()) SWIG_fail;
4224 PyThreadState* __tstate = wxPyBeginAllowThreads();
4225 result = (bool)wxSystemSettings::HasFeature(arg1);
4226 wxPyEndAllowThreads(__tstate);
4227 if (PyErr_Occurred()) SWIG_fail;
4228 }
4229 {
4230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4231 }
4232 return resultobj;
4233 fail:
4234 return NULL;
4235 }
4236
4237
4238 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4239 PyObject *resultobj = 0;
4240 wxSystemScreenType result;
4241
4242 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4243 {
4244 if (!wxPyCheckForApp()) SWIG_fail;
4245 PyThreadState* __tstate = wxPyBeginAllowThreads();
4246 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4247 wxPyEndAllowThreads(__tstate);
4248 if (PyErr_Occurred()) SWIG_fail;
4249 }
4250 resultobj = SWIG_From_int(static_cast< int >(result));
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj = 0;
4259 wxSystemScreenType arg1 ;
4260 int val1 ;
4261 int ecode1 = 0 ;
4262 PyObject * obj0 = 0 ;
4263 char * kwnames[] = {
4264 (char *) "screen", NULL
4265 };
4266
4267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4268 ecode1 = SWIG_AsVal_int(obj0, &val1);
4269 if (!SWIG_IsOK(ecode1)) {
4270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4271 }
4272 arg1 = static_cast< wxSystemScreenType >(val1);
4273 {
4274 if (!wxPyCheckForApp()) SWIG_fail;
4275 PyThreadState* __tstate = wxPyBeginAllowThreads();
4276 wxSystemSettings::SetScreenType(arg1);
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 resultobj = SWIG_Py_Void();
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4288 PyObject *obj;
4289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4290 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4291 return SWIG_Py_Void();
4292 }
4293
4294 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4295 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4296 return 1;
4297 }
4298
4299
4300 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4301 PyObject *pyobj = 0;
4302
4303 {
4304 #if wxUSE_UNICODE
4305 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4306 #else
4307 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4308 #endif
4309 }
4310 return pyobj;
4311 }
4312
4313
4314 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4315 PyObject *resultobj = 0;
4316 wxSystemOptions *result = 0 ;
4317
4318 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4319 {
4320 PyThreadState* __tstate = wxPyBeginAllowThreads();
4321 result = (wxSystemOptions *)new wxSystemOptions();
4322 wxPyEndAllowThreads(__tstate);
4323 if (PyErr_Occurred()) SWIG_fail;
4324 }
4325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4326 return resultobj;
4327 fail:
4328 return NULL;
4329 }
4330
4331
4332 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4333 PyObject *resultobj = 0;
4334 wxString *arg1 = 0 ;
4335 wxString *arg2 = 0 ;
4336 bool temp1 = false ;
4337 bool temp2 = false ;
4338 PyObject * obj0 = 0 ;
4339 PyObject * obj1 = 0 ;
4340 char * kwnames[] = {
4341 (char *) "name",(char *) "value", NULL
4342 };
4343
4344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4345 {
4346 arg1 = wxString_in_helper(obj0);
4347 if (arg1 == NULL) SWIG_fail;
4348 temp1 = true;
4349 }
4350 {
4351 arg2 = wxString_in_helper(obj1);
4352 if (arg2 == NULL) SWIG_fail;
4353 temp2 = true;
4354 }
4355 {
4356 PyThreadState* __tstate = wxPyBeginAllowThreads();
4357 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4358 wxPyEndAllowThreads(__tstate);
4359 if (PyErr_Occurred()) SWIG_fail;
4360 }
4361 resultobj = SWIG_Py_Void();
4362 {
4363 if (temp1)
4364 delete arg1;
4365 }
4366 {
4367 if (temp2)
4368 delete arg2;
4369 }
4370 return resultobj;
4371 fail:
4372 {
4373 if (temp1)
4374 delete arg1;
4375 }
4376 {
4377 if (temp2)
4378 delete arg2;
4379 }
4380 return NULL;
4381 }
4382
4383
4384 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4385 PyObject *resultobj = 0;
4386 wxString *arg1 = 0 ;
4387 int arg2 ;
4388 bool temp1 = false ;
4389 int val2 ;
4390 int ecode2 = 0 ;
4391 PyObject * obj0 = 0 ;
4392 PyObject * obj1 = 0 ;
4393 char * kwnames[] = {
4394 (char *) "name",(char *) "value", NULL
4395 };
4396
4397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4398 {
4399 arg1 = wxString_in_helper(obj0);
4400 if (arg1 == NULL) SWIG_fail;
4401 temp1 = true;
4402 }
4403 ecode2 = SWIG_AsVal_int(obj1, &val2);
4404 if (!SWIG_IsOK(ecode2)) {
4405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4406 }
4407 arg2 = static_cast< int >(val2);
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 resultobj = SWIG_Py_Void();
4415 {
4416 if (temp1)
4417 delete arg1;
4418 }
4419 return resultobj;
4420 fail:
4421 {
4422 if (temp1)
4423 delete arg1;
4424 }
4425 return NULL;
4426 }
4427
4428
4429 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4430 PyObject *resultobj = 0;
4431 wxString *arg1 = 0 ;
4432 wxString result;
4433 bool temp1 = false ;
4434 PyObject * obj0 = 0 ;
4435 char * kwnames[] = {
4436 (char *) "name", NULL
4437 };
4438
4439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4440 {
4441 arg1 = wxString_in_helper(obj0);
4442 if (arg1 == NULL) SWIG_fail;
4443 temp1 = true;
4444 }
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 {
4452 #if wxUSE_UNICODE
4453 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4454 #else
4455 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4456 #endif
4457 }
4458 {
4459 if (temp1)
4460 delete arg1;
4461 }
4462 return resultobj;
4463 fail:
4464 {
4465 if (temp1)
4466 delete arg1;
4467 }
4468 return NULL;
4469 }
4470
4471
4472 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4473 PyObject *resultobj = 0;
4474 wxString *arg1 = 0 ;
4475 int result;
4476 bool temp1 = false ;
4477 PyObject * obj0 = 0 ;
4478 char * kwnames[] = {
4479 (char *) "name", NULL
4480 };
4481
4482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4483 {
4484 arg1 = wxString_in_helper(obj0);
4485 if (arg1 == NULL) SWIG_fail;
4486 temp1 = true;
4487 }
4488 {
4489 PyThreadState* __tstate = wxPyBeginAllowThreads();
4490 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4491 wxPyEndAllowThreads(__tstate);
4492 if (PyErr_Occurred()) SWIG_fail;
4493 }
4494 resultobj = SWIG_From_int(static_cast< int >(result));
4495 {
4496 if (temp1)
4497 delete arg1;
4498 }
4499 return resultobj;
4500 fail:
4501 {
4502 if (temp1)
4503 delete arg1;
4504 }
4505 return NULL;
4506 }
4507
4508
4509 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4510 PyObject *resultobj = 0;
4511 wxString *arg1 = 0 ;
4512 bool result;
4513 bool temp1 = false ;
4514 PyObject * obj0 = 0 ;
4515 char * kwnames[] = {
4516 (char *) "name", NULL
4517 };
4518
4519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4520 {
4521 arg1 = wxString_in_helper(obj0);
4522 if (arg1 == NULL) SWIG_fail;
4523 temp1 = true;
4524 }
4525 {
4526 PyThreadState* __tstate = wxPyBeginAllowThreads();
4527 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4528 wxPyEndAllowThreads(__tstate);
4529 if (PyErr_Occurred()) SWIG_fail;
4530 }
4531 {
4532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4533 }
4534 {
4535 if (temp1)
4536 delete arg1;
4537 }
4538 return resultobj;
4539 fail:
4540 {
4541 if (temp1)
4542 delete arg1;
4543 }
4544 return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4549 PyObject *resultobj = 0;
4550 wxString *arg1 = 0 ;
4551 bool result;
4552 bool temp1 = false ;
4553 PyObject * obj0 = 0 ;
4554 char * kwnames[] = {
4555 (char *) "name", NULL
4556 };
4557
4558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4559 {
4560 arg1 = wxString_in_helper(obj0);
4561 if (arg1 == NULL) SWIG_fail;
4562 temp1 = true;
4563 }
4564 {
4565 PyThreadState* __tstate = wxPyBeginAllowThreads();
4566 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4567 wxPyEndAllowThreads(__tstate);
4568 if (PyErr_Occurred()) SWIG_fail;
4569 }
4570 {
4571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4572 }
4573 {
4574 if (temp1)
4575 delete arg1;
4576 }
4577 return resultobj;
4578 fail:
4579 {
4580 if (temp1)
4581 delete arg1;
4582 }
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4588 PyObject *obj;
4589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4590 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4591 return SWIG_Py_Void();
4592 }
4593
4594 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4595 return SWIG_Python_InitShadowInstance(args);
4596 }
4597
4598 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4599 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4600 return 1;
4601 }
4602
4603
4604 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4605 PyObject *pyobj = 0;
4606
4607 {
4608 #if wxUSE_UNICODE
4609 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4610 #else
4611 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4612 #endif
4613 }
4614 return pyobj;
4615 }
4616
4617
4618 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4619 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4620 return 1;
4621 }
4622
4623
4624 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4625 PyObject *pyobj = 0;
4626
4627 {
4628 #if wxUSE_UNICODE
4629 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4630 #else
4631 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4632 #endif
4633 }
4634 return pyobj;
4635 }
4636
4637
4638 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4639 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4640 return 1;
4641 }
4642
4643
4644 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4645 PyObject *pyobj = 0;
4646
4647 {
4648 #if wxUSE_UNICODE
4649 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4650 #else
4651 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4652 #endif
4653 }
4654 return pyobj;
4655 }
4656
4657
4658 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4659 PyObject *resultobj = 0;
4660 long result;
4661
4662 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4663 {
4664 PyThreadState* __tstate = wxPyBeginAllowThreads();
4665 result = (long)wxNewId();
4666 wxPyEndAllowThreads(__tstate);
4667 if (PyErr_Occurred()) SWIG_fail;
4668 }
4669 resultobj = SWIG_From_long(static_cast< long >(result));
4670 return resultobj;
4671 fail:
4672 return NULL;
4673 }
4674
4675
4676 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4677 PyObject *resultobj = 0;
4678 long arg1 ;
4679 long val1 ;
4680 int ecode1 = 0 ;
4681 PyObject * obj0 = 0 ;
4682 char * kwnames[] = {
4683 (char *) "id", NULL
4684 };
4685
4686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4687 ecode1 = SWIG_AsVal_long(obj0, &val1);
4688 if (!SWIG_IsOK(ecode1)) {
4689 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4690 }
4691 arg1 = static_cast< long >(val1);
4692 {
4693 PyThreadState* __tstate = wxPyBeginAllowThreads();
4694 wxRegisterId(arg1);
4695 wxPyEndAllowThreads(__tstate);
4696 if (PyErr_Occurred()) SWIG_fail;
4697 }
4698 resultobj = SWIG_Py_Void();
4699 return resultobj;
4700 fail:
4701 return NULL;
4702 }
4703
4704
4705 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4706 PyObject *resultobj = 0;
4707 long result;
4708
4709 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4710 {
4711 PyThreadState* __tstate = wxPyBeginAllowThreads();
4712 result = (long)wxGetCurrentId();
4713 wxPyEndAllowThreads(__tstate);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 resultobj = SWIG_From_long(static_cast< long >(result));
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = 0;
4725 int arg1 ;
4726 bool result;
4727 int val1 ;
4728 int ecode1 = 0 ;
4729 PyObject * obj0 = 0 ;
4730 char * kwnames[] = {
4731 (char *) "id", NULL
4732 };
4733
4734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4735 ecode1 = SWIG_AsVal_int(obj0, &val1);
4736 if (!SWIG_IsOK(ecode1)) {
4737 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4738 }
4739 arg1 = static_cast< int >(val1);
4740 {
4741 PyThreadState* __tstate = wxPyBeginAllowThreads();
4742 result = (bool)wxIsStockID(arg1);
4743 wxPyEndAllowThreads(__tstate);
4744 if (PyErr_Occurred()) SWIG_fail;
4745 }
4746 {
4747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4748 }
4749 return resultobj;
4750 fail:
4751 return NULL;
4752 }
4753
4754
4755 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4756 PyObject *resultobj = 0;
4757 int arg1 ;
4758 wxString *arg2 = 0 ;
4759 bool result;
4760 int val1 ;
4761 int ecode1 = 0 ;
4762 bool temp2 = false ;
4763 PyObject * obj0 = 0 ;
4764 PyObject * obj1 = 0 ;
4765 char * kwnames[] = {
4766 (char *) "id",(char *) "label", NULL
4767 };
4768
4769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4770 ecode1 = SWIG_AsVal_int(obj0, &val1);
4771 if (!SWIG_IsOK(ecode1)) {
4772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4773 }
4774 arg1 = static_cast< int >(val1);
4775 {
4776 arg2 = wxString_in_helper(obj1);
4777 if (arg2 == NULL) SWIG_fail;
4778 temp2 = true;
4779 }
4780 {
4781 PyThreadState* __tstate = wxPyBeginAllowThreads();
4782 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4783 wxPyEndAllowThreads(__tstate);
4784 if (PyErr_Occurred()) SWIG_fail;
4785 }
4786 {
4787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4788 }
4789 {
4790 if (temp2)
4791 delete arg2;
4792 }
4793 return resultobj;
4794 fail:
4795 {
4796 if (temp2)
4797 delete arg2;
4798 }
4799 return NULL;
4800 }
4801
4802
4803 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4804 PyObject *resultobj = 0;
4805 int arg1 ;
4806 long arg2 = (long) wxSTOCK_WITH_MNEMONIC ;
4807 wxString result;
4808 int val1 ;
4809 int ecode1 = 0 ;
4810 long val2 ;
4811 int ecode2 = 0 ;
4812 PyObject * obj0 = 0 ;
4813 PyObject * obj1 = 0 ;
4814 char * kwnames[] = {
4815 (char *) "id",(char *) "flags", NULL
4816 };
4817
4818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4819 ecode1 = SWIG_AsVal_int(obj0, &val1);
4820 if (!SWIG_IsOK(ecode1)) {
4821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4822 }
4823 arg1 = static_cast< int >(val1);
4824 if (obj1) {
4825 ecode2 = SWIG_AsVal_long(obj1, &val2);
4826 if (!SWIG_IsOK(ecode2)) {
4827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "long""'");
4828 }
4829 arg2 = static_cast< long >(val2);
4830 }
4831 {
4832 PyThreadState* __tstate = wxPyBeginAllowThreads();
4833 result = wxGetStockLabel(arg1,arg2);
4834 wxPyEndAllowThreads(__tstate);
4835 if (PyErr_Occurred()) SWIG_fail;
4836 }
4837 {
4838 #if wxUSE_UNICODE
4839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4840 #else
4841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4842 #endif
4843 }
4844 return resultobj;
4845 fail:
4846 return NULL;
4847 }
4848
4849
4850 SWIGINTERN PyObject *_wrap_GetStockHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4851 PyObject *resultobj = 0;
4852 int arg1 ;
4853 wxStockHelpStringClient arg2 = (wxStockHelpStringClient) wxSTOCK_MENU ;
4854 wxString result;
4855 int val1 ;
4856 int ecode1 = 0 ;
4857 int val2 ;
4858 int ecode2 = 0 ;
4859 PyObject * obj0 = 0 ;
4860 PyObject * obj1 = 0 ;
4861 char * kwnames[] = {
4862 (char *) "id",(char *) "client", NULL
4863 };
4864
4865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:GetStockHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
4866 ecode1 = SWIG_AsVal_int(obj0, &val1);
4867 if (!SWIG_IsOK(ecode1)) {
4868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockHelpString" "', expected argument " "1"" of type '" "int""'");
4869 }
4870 arg1 = static_cast< int >(val1);
4871 if (obj1) {
4872 ecode2 = SWIG_AsVal_int(obj1, &val2);
4873 if (!SWIG_IsOK(ecode2)) {
4874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockHelpString" "', expected argument " "2"" of type '" "wxStockHelpStringClient""'");
4875 }
4876 arg2 = static_cast< wxStockHelpStringClient >(val2);
4877 }
4878 {
4879 PyThreadState* __tstate = wxPyBeginAllowThreads();
4880 result = wxGetStockHelpString(arg1,arg2);
4881 wxPyEndAllowThreads(__tstate);
4882 if (PyErr_Occurred()) SWIG_fail;
4883 }
4884 {
4885 #if wxUSE_UNICODE
4886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4887 #else
4888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4889 #endif
4890 }
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4898 PyObject *resultobj = 0;
4899
4900 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4901 {
4902 if (!wxPyCheckForApp()) SWIG_fail;
4903 PyThreadState* __tstate = wxPyBeginAllowThreads();
4904 wxBell();
4905 wxPyEndAllowThreads(__tstate);
4906 if (PyErr_Occurred()) SWIG_fail;
4907 }
4908 resultobj = SWIG_Py_Void();
4909 return resultobj;
4910 fail:
4911 return NULL;
4912 }
4913
4914
4915 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4916 PyObject *resultobj = 0;
4917
4918 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4919 {
4920 if (!wxPyCheckForApp()) SWIG_fail;
4921 PyThreadState* __tstate = wxPyBeginAllowThreads();
4922 wxEndBusyCursor();
4923 wxPyEndAllowThreads(__tstate);
4924 if (PyErr_Occurred()) SWIG_fail;
4925 }
4926 resultobj = SWIG_Py_Void();
4927 return resultobj;
4928 fail:
4929 return NULL;
4930 }
4931
4932
4933 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4934 PyObject *resultobj = 0;
4935 bool arg1 = (bool) true ;
4936 long result;
4937 bool val1 ;
4938 int ecode1 = 0 ;
4939 PyObject * obj0 = 0 ;
4940 char * kwnames[] = {
4941 (char *) "resetTimer", NULL
4942 };
4943
4944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4945 if (obj0) {
4946 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4947 if (!SWIG_IsOK(ecode1)) {
4948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4949 }
4950 arg1 = static_cast< bool >(val1);
4951 }
4952 {
4953 PyThreadState* __tstate = wxPyBeginAllowThreads();
4954 result = (long)wxGetElapsedTime(arg1);
4955 wxPyEndAllowThreads(__tstate);
4956 if (PyErr_Occurred()) SWIG_fail;
4957 }
4958 resultobj = SWIG_From_long(static_cast< long >(result));
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4966 PyObject *resultobj = 0;
4967 bool result;
4968
4969 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4970 {
4971 PyThreadState* __tstate = wxPyBeginAllowThreads();
4972 result = (bool)wxIsBusy();
4973 wxPyEndAllowThreads(__tstate);
4974 if (PyErr_Occurred()) SWIG_fail;
4975 }
4976 {
4977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4978 }
4979 return resultobj;
4980 fail:
4981 return NULL;
4982 }
4983
4984
4985 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4986 PyObject *resultobj = 0;
4987 wxString result;
4988
4989 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4990 {
4991 PyThreadState* __tstate = wxPyBeginAllowThreads();
4992 result = wxNow();
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 {
4997 #if wxUSE_UNICODE
4998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4999 #else
5000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5001 #endif
5002 }
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5010 PyObject *resultobj = 0;
5011 wxString const &arg1_defvalue = wxPyEmptyString ;
5012 wxString *arg1 = (wxString *) &arg1_defvalue ;
5013 bool result;
5014 bool temp1 = false ;
5015 PyObject * obj0 = 0 ;
5016 char * kwnames[] = {
5017 (char *) "command", NULL
5018 };
5019
5020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
5021 if (obj0) {
5022 {
5023 arg1 = wxString_in_helper(obj0);
5024 if (arg1 == NULL) SWIG_fail;
5025 temp1 = true;
5026 }
5027 }
5028 {
5029 PyThreadState* __tstate = wxPyBeginAllowThreads();
5030 result = (bool)wxShell((wxString const &)*arg1);
5031 wxPyEndAllowThreads(__tstate);
5032 if (PyErr_Occurred()) SWIG_fail;
5033 }
5034 {
5035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5036 }
5037 {
5038 if (temp1)
5039 delete arg1;
5040 }
5041 return resultobj;
5042 fail:
5043 {
5044 if (temp1)
5045 delete arg1;
5046 }
5047 return NULL;
5048 }
5049
5050
5051 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5052 PyObject *resultobj = 0;
5053
5054 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5055 {
5056 PyThreadState* __tstate = wxPyBeginAllowThreads();
5057 wxStartTimer();
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_Py_Void();
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5069 PyObject *resultobj = 0;
5070 int *arg1 = (int *) 0 ;
5071 int *arg2 = (int *) 0 ;
5072 int result;
5073 int temp1 ;
5074 int res1 = SWIG_TMPOBJ ;
5075 int temp2 ;
5076 int res2 = SWIG_TMPOBJ ;
5077
5078 arg1 = &temp1;
5079 arg2 = &temp2;
5080 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5081 {
5082 PyThreadState* __tstate = wxPyBeginAllowThreads();
5083 result = (int)wxGetOsVersion(arg1,arg2);
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 resultobj = SWIG_From_int(static_cast< int >(result));
5088 if (SWIG_IsTmpObj(res1)) {
5089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5090 } else {
5091 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5093 }
5094 if (SWIG_IsTmpObj(res2)) {
5095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5096 } else {
5097 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5099 }
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5107 PyObject *resultobj = 0;
5108 wxString result;
5109
5110 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5111 {
5112 PyThreadState* __tstate = wxPyBeginAllowThreads();
5113 result = wxGetOsDescription();
5114 wxPyEndAllowThreads(__tstate);
5115 if (PyErr_Occurred()) SWIG_fail;
5116 }
5117 {
5118 #if wxUSE_UNICODE
5119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5120 #else
5121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5122 #endif
5123 }
5124 return resultobj;
5125 fail:
5126 return NULL;
5127 }
5128
5129
5130 SWIGINTERN PyObject *_wrap_IsPlatformLittleEndian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5131 PyObject *resultobj = 0;
5132 bool result;
5133
5134 if (!SWIG_Python_UnpackTuple(args,"IsPlatformLittleEndian",0,0,0)) SWIG_fail;
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 result = (bool)wxIsPlatformLittleEndian();
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 {
5142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5143 }
5144 return resultobj;
5145 fail:
5146 return NULL;
5147 }
5148
5149
5150 SWIGINTERN PyObject *_wrap_IsPlatform64Bit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5151 PyObject *resultobj = 0;
5152 bool result;
5153
5154 if (!SWIG_Python_UnpackTuple(args,"IsPlatform64Bit",0,0,0)) SWIG_fail;
5155 {
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 result = (bool)wxIsPlatform64Bit();
5158 wxPyEndAllowThreads(__tstate);
5159 if (PyErr_Occurred()) SWIG_fail;
5160 }
5161 {
5162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5163 }
5164 return resultobj;
5165 fail:
5166 return NULL;
5167 }
5168
5169
5170 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5171 PyObject *resultobj = 0;
5172 wxMemorySize result;
5173
5174 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5175 {
5176 PyThreadState* __tstate = wxPyBeginAllowThreads();
5177 result = wxGetFreeMemory();
5178 wxPyEndAllowThreads(__tstate);
5179 if (PyErr_Occurred()) SWIG_fail;
5180 }
5181 {
5182 #if wxUSE_LONGLONG
5183 resultobj = PyLong_FromLongLong((&result)->GetValue());
5184 #else
5185 resultobj = PyInt_FromLong(result);
5186 #endif
5187 }
5188 return resultobj;
5189 fail:
5190 return NULL;
5191 }
5192
5193
5194 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5195 PyObject *resultobj = 0;
5196 wxShutdownFlags arg1 ;
5197 bool result;
5198 int val1 ;
5199 int ecode1 = 0 ;
5200 PyObject * obj0 = 0 ;
5201 char * kwnames[] = {
5202 (char *) "wFlags", NULL
5203 };
5204
5205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5206 ecode1 = SWIG_AsVal_int(obj0, &val1);
5207 if (!SWIG_IsOK(ecode1)) {
5208 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5209 }
5210 arg1 = static_cast< wxShutdownFlags >(val1);
5211 {
5212 if (!wxPyCheckForApp()) SWIG_fail;
5213 PyThreadState* __tstate = wxPyBeginAllowThreads();
5214 result = (bool)wxShutdown(arg1);
5215 wxPyEndAllowThreads(__tstate);
5216 if (PyErr_Occurred()) SWIG_fail;
5217 }
5218 {
5219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5220 }
5221 return resultobj;
5222 fail:
5223 return NULL;
5224 }
5225
5226
5227 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5228 PyObject *resultobj = 0;
5229 int arg1 ;
5230 int val1 ;
5231 int ecode1 = 0 ;
5232 PyObject * obj0 = 0 ;
5233 char * kwnames[] = {
5234 (char *) "secs", NULL
5235 };
5236
5237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5238 ecode1 = SWIG_AsVal_int(obj0, &val1);
5239 if (!SWIG_IsOK(ecode1)) {
5240 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5241 }
5242 arg1 = static_cast< int >(val1);
5243 {
5244 PyThreadState* __tstate = wxPyBeginAllowThreads();
5245 wxSleep(arg1);
5246 wxPyEndAllowThreads(__tstate);
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 resultobj = SWIG_Py_Void();
5250 return resultobj;
5251 fail:
5252 return NULL;
5253 }
5254
5255
5256 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5257 PyObject *resultobj = 0;
5258 unsigned long arg1 ;
5259 unsigned long val1 ;
5260 int ecode1 = 0 ;
5261 PyObject * obj0 = 0 ;
5262 char * kwnames[] = {
5263 (char *) "milliseconds", NULL
5264 };
5265
5266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5267 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5268 if (!SWIG_IsOK(ecode1)) {
5269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5270 }
5271 arg1 = static_cast< unsigned long >(val1);
5272 {
5273 PyThreadState* __tstate = wxPyBeginAllowThreads();
5274 wxMilliSleep(arg1);
5275 wxPyEndAllowThreads(__tstate);
5276 if (PyErr_Occurred()) SWIG_fail;
5277 }
5278 resultobj = SWIG_Py_Void();
5279 return resultobj;
5280 fail:
5281 return NULL;
5282 }
5283
5284
5285 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5286 PyObject *resultobj = 0;
5287 unsigned long arg1 ;
5288 unsigned long val1 ;
5289 int ecode1 = 0 ;
5290 PyObject * obj0 = 0 ;
5291 char * kwnames[] = {
5292 (char *) "microseconds", NULL
5293 };
5294
5295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5296 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5297 if (!SWIG_IsOK(ecode1)) {
5298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5299 }
5300 arg1 = static_cast< unsigned long >(val1);
5301 {
5302 PyThreadState* __tstate = wxPyBeginAllowThreads();
5303 wxMicroSleep(arg1);
5304 wxPyEndAllowThreads(__tstate);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 resultobj = SWIG_Py_Void();
5308 return resultobj;
5309 fail:
5310 return NULL;
5311 }
5312
5313
5314 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5315 PyObject *resultobj = 0;
5316 bool arg1 ;
5317 bool val1 ;
5318 int ecode1 = 0 ;
5319 PyObject * obj0 = 0 ;
5320 char * kwnames[] = {
5321 (char *) "enable", NULL
5322 };
5323
5324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5325 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5326 if (!SWIG_IsOK(ecode1)) {
5327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5328 }
5329 arg1 = static_cast< bool >(val1);
5330 {
5331 PyThreadState* __tstate = wxPyBeginAllowThreads();
5332 wxEnableTopLevelWindows(arg1);
5333 wxPyEndAllowThreads(__tstate);
5334 if (PyErr_Occurred()) SWIG_fail;
5335 }
5336 resultobj = SWIG_Py_Void();
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj = 0;
5345 wxString *arg1 = 0 ;
5346 wxString result;
5347 bool temp1 = false ;
5348 PyObject * obj0 = 0 ;
5349 char * kwnames[] = {
5350 (char *) "in", NULL
5351 };
5352
5353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5354 {
5355 arg1 = wxString_in_helper(obj0);
5356 if (arg1 == NULL) SWIG_fail;
5357 temp1 = true;
5358 }
5359 {
5360 PyThreadState* __tstate = wxPyBeginAllowThreads();
5361 result = wxStripMenuCodes((wxString const &)*arg1);
5362 wxPyEndAllowThreads(__tstate);
5363 if (PyErr_Occurred()) SWIG_fail;
5364 }
5365 {
5366 #if wxUSE_UNICODE
5367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5368 #else
5369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5370 #endif
5371 }
5372 {
5373 if (temp1)
5374 delete arg1;
5375 }
5376 return resultobj;
5377 fail:
5378 {
5379 if (temp1)
5380 delete arg1;
5381 }
5382 return NULL;
5383 }
5384
5385
5386 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5387 PyObject *resultobj = 0;
5388 wxString result;
5389
5390 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5391 {
5392 PyThreadState* __tstate = wxPyBeginAllowThreads();
5393 result = wxGetEmailAddress();
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 {
5398 #if wxUSE_UNICODE
5399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5400 #else
5401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5402 #endif
5403 }
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5411 PyObject *resultobj = 0;
5412 wxString result;
5413
5414 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5415 {
5416 PyThreadState* __tstate = wxPyBeginAllowThreads();
5417 result = wxGetHostName();
5418 wxPyEndAllowThreads(__tstate);
5419 if (PyErr_Occurred()) SWIG_fail;
5420 }
5421 {
5422 #if wxUSE_UNICODE
5423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5424 #else
5425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5426 #endif
5427 }
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5435 PyObject *resultobj = 0;
5436 wxString result;
5437
5438 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5439 {
5440 PyThreadState* __tstate = wxPyBeginAllowThreads();
5441 result = wxGetFullHostName();
5442 wxPyEndAllowThreads(__tstate);
5443 if (PyErr_Occurred()) SWIG_fail;
5444 }
5445 {
5446 #if wxUSE_UNICODE
5447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5448 #else
5449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5450 #endif
5451 }
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5459 PyObject *resultobj = 0;
5460 wxString result;
5461
5462 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5463 {
5464 PyThreadState* __tstate = wxPyBeginAllowThreads();
5465 result = wxGetUserId();
5466 wxPyEndAllowThreads(__tstate);
5467 if (PyErr_Occurred()) SWIG_fail;
5468 }
5469 {
5470 #if wxUSE_UNICODE
5471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5472 #else
5473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5474 #endif
5475 }
5476 return resultobj;
5477 fail:
5478 return NULL;
5479 }
5480
5481
5482 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5483 PyObject *resultobj = 0;
5484 wxString result;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5487 {
5488 PyThreadState* __tstate = wxPyBeginAllowThreads();
5489 result = wxGetUserName();
5490 wxPyEndAllowThreads(__tstate);
5491 if (PyErr_Occurred()) SWIG_fail;
5492 }
5493 {
5494 #if wxUSE_UNICODE
5495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5496 #else
5497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5498 #endif
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *resultobj = 0;
5508 wxString result;
5509
5510 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5511 {
5512 PyThreadState* __tstate = wxPyBeginAllowThreads();
5513 result = wxGetHomeDir();
5514 wxPyEndAllowThreads(__tstate);
5515 if (PyErr_Occurred()) SWIG_fail;
5516 }
5517 {
5518 #if wxUSE_UNICODE
5519 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5520 #else
5521 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5522 #endif
5523 }
5524 return resultobj;
5525 fail:
5526 return NULL;
5527 }
5528
5529
5530 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5531 PyObject *resultobj = 0;
5532 wxString const &arg1_defvalue = wxPyEmptyString ;
5533 wxString *arg1 = (wxString *) &arg1_defvalue ;
5534 wxString result;
5535 bool temp1 = false ;
5536 PyObject * obj0 = 0 ;
5537 char * kwnames[] = {
5538 (char *) "user", NULL
5539 };
5540
5541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5542 if (obj0) {
5543 {
5544 arg1 = wxString_in_helper(obj0);
5545 if (arg1 == NULL) SWIG_fail;
5546 temp1 = true;
5547 }
5548 }
5549 {
5550 PyThreadState* __tstate = wxPyBeginAllowThreads();
5551 result = wxGetUserHome((wxString const &)*arg1);
5552 wxPyEndAllowThreads(__tstate);
5553 if (PyErr_Occurred()) SWIG_fail;
5554 }
5555 {
5556 #if wxUSE_UNICODE
5557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5558 #else
5559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5560 #endif
5561 }
5562 {
5563 if (temp1)
5564 delete arg1;
5565 }
5566 return resultobj;
5567 fail:
5568 {
5569 if (temp1)
5570 delete arg1;
5571 }
5572 return NULL;
5573 }
5574
5575
5576 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5577 PyObject *resultobj = 0;
5578 unsigned long result;
5579
5580 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5581 {
5582 PyThreadState* __tstate = wxPyBeginAllowThreads();
5583 result = (unsigned long)wxGetProcessId();
5584 wxPyEndAllowThreads(__tstate);
5585 if (PyErr_Occurred()) SWIG_fail;
5586 }
5587 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5595 PyObject *resultobj = 0;
5596
5597 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5598 {
5599 PyThreadState* __tstate = wxPyBeginAllowThreads();
5600 wxTrap();
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 resultobj = SWIG_Py_Void();
5605 return resultobj;
5606 fail:
5607 return NULL;
5608 }
5609
5610
5611 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5612 PyObject *resultobj = 0;
5613 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5614 wxString *arg1 = (wxString *) &arg1_defvalue ;
5615 wxString const &arg2_defvalue = wxPyEmptyString ;
5616 wxString *arg2 = (wxString *) &arg2_defvalue ;
5617 wxString const &arg3_defvalue = wxPyEmptyString ;
5618 wxString *arg3 = (wxString *) &arg3_defvalue ;
5619 wxString const &arg4_defvalue = wxPyEmptyString ;
5620 wxString *arg4 = (wxString *) &arg4_defvalue ;
5621 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5622 wxString *arg5 = (wxString *) &arg5_defvalue ;
5623 int arg6 = (int) 0 ;
5624 wxWindow *arg7 = (wxWindow *) NULL ;
5625 int arg8 = (int) -1 ;
5626 int arg9 = (int) -1 ;
5627 wxString result;
5628 bool temp1 = false ;
5629 bool temp2 = false ;
5630 bool temp3 = false ;
5631 bool temp4 = false ;
5632 bool temp5 = false ;
5633 int val6 ;
5634 int ecode6 = 0 ;
5635 void *argp7 = 0 ;
5636 int res7 = 0 ;
5637 int val8 ;
5638 int ecode8 = 0 ;
5639 int val9 ;
5640 int ecode9 = 0 ;
5641 PyObject * obj0 = 0 ;
5642 PyObject * obj1 = 0 ;
5643 PyObject * obj2 = 0 ;
5644 PyObject * obj3 = 0 ;
5645 PyObject * obj4 = 0 ;
5646 PyObject * obj5 = 0 ;
5647 PyObject * obj6 = 0 ;
5648 PyObject * obj7 = 0 ;
5649 PyObject * obj8 = 0 ;
5650 char * kwnames[] = {
5651 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5652 };
5653
5654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5655 if (obj0) {
5656 {
5657 arg1 = wxString_in_helper(obj0);
5658 if (arg1 == NULL) SWIG_fail;
5659 temp1 = true;
5660 }
5661 }
5662 if (obj1) {
5663 {
5664 arg2 = wxString_in_helper(obj1);
5665 if (arg2 == NULL) SWIG_fail;
5666 temp2 = true;
5667 }
5668 }
5669 if (obj2) {
5670 {
5671 arg3 = wxString_in_helper(obj2);
5672 if (arg3 == NULL) SWIG_fail;
5673 temp3 = true;
5674 }
5675 }
5676 if (obj3) {
5677 {
5678 arg4 = wxString_in_helper(obj3);
5679 if (arg4 == NULL) SWIG_fail;
5680 temp4 = true;
5681 }
5682 }
5683 if (obj4) {
5684 {
5685 arg5 = wxString_in_helper(obj4);
5686 if (arg5 == NULL) SWIG_fail;
5687 temp5 = true;
5688 }
5689 }
5690 if (obj5) {
5691 ecode6 = SWIG_AsVal_int(obj5, &val6);
5692 if (!SWIG_IsOK(ecode6)) {
5693 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5694 }
5695 arg6 = static_cast< int >(val6);
5696 }
5697 if (obj6) {
5698 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5699 if (!SWIG_IsOK(res7)) {
5700 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5701 }
5702 arg7 = reinterpret_cast< wxWindow * >(argp7);
5703 }
5704 if (obj7) {
5705 ecode8 = SWIG_AsVal_int(obj7, &val8);
5706 if (!SWIG_IsOK(ecode8)) {
5707 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5708 }
5709 arg8 = static_cast< int >(val8);
5710 }
5711 if (obj8) {
5712 ecode9 = SWIG_AsVal_int(obj8, &val9);
5713 if (!SWIG_IsOK(ecode9)) {
5714 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5715 }
5716 arg9 = static_cast< int >(val9);
5717 }
5718 {
5719 if (!wxPyCheckForApp()) SWIG_fail;
5720 PyThreadState* __tstate = wxPyBeginAllowThreads();
5721 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5722 wxPyEndAllowThreads(__tstate);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 {
5726 #if wxUSE_UNICODE
5727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5728 #else
5729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5730 #endif
5731 }
5732 {
5733 if (temp1)
5734 delete arg1;
5735 }
5736 {
5737 if (temp2)
5738 delete arg2;
5739 }
5740 {
5741 if (temp3)
5742 delete arg3;
5743 }
5744 {
5745 if (temp4)
5746 delete arg4;
5747 }
5748 {
5749 if (temp5)
5750 delete arg5;
5751 }
5752 return resultobj;
5753 fail:
5754 {
5755 if (temp1)
5756 delete arg1;
5757 }
5758 {
5759 if (temp2)
5760 delete arg2;
5761 }
5762 {
5763 if (temp3)
5764 delete arg3;
5765 }
5766 {
5767 if (temp4)
5768 delete arg4;
5769 }
5770 {
5771 if (temp5)
5772 delete arg5;
5773 }
5774 return NULL;
5775 }
5776
5777
5778 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5779 PyObject *resultobj = 0;
5780 wxString *arg1 = 0 ;
5781 wxString *arg2 = 0 ;
5782 wxString const &arg3_defvalue = wxPyEmptyString ;
5783 wxString *arg3 = (wxString *) &arg3_defvalue ;
5784 wxWindow *arg4 = (wxWindow *) NULL ;
5785 wxString result;
5786 bool temp1 = false ;
5787 bool temp2 = false ;
5788 bool temp3 = false ;
5789 void *argp4 = 0 ;
5790 int res4 = 0 ;
5791 PyObject * obj0 = 0 ;
5792 PyObject * obj1 = 0 ;
5793 PyObject * obj2 = 0 ;
5794 PyObject * obj3 = 0 ;
5795 char * kwnames[] = {
5796 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5797 };
5798
5799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5800 {
5801 arg1 = wxString_in_helper(obj0);
5802 if (arg1 == NULL) SWIG_fail;
5803 temp1 = true;
5804 }
5805 {
5806 arg2 = wxString_in_helper(obj1);
5807 if (arg2 == NULL) SWIG_fail;
5808 temp2 = true;
5809 }
5810 if (obj2) {
5811 {
5812 arg3 = wxString_in_helper(obj2);
5813 if (arg3 == NULL) SWIG_fail;
5814 temp3 = true;
5815 }
5816 }
5817 if (obj3) {
5818 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5819 if (!SWIG_IsOK(res4)) {
5820 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5821 }
5822 arg4 = reinterpret_cast< wxWindow * >(argp4);
5823 }
5824 {
5825 if (!wxPyCheckForApp()) SWIG_fail;
5826 PyThreadState* __tstate = wxPyBeginAllowThreads();
5827 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5828 wxPyEndAllowThreads(__tstate);
5829 if (PyErr_Occurred()) SWIG_fail;
5830 }
5831 {
5832 #if wxUSE_UNICODE
5833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5834 #else
5835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5836 #endif
5837 }
5838 {
5839 if (temp1)
5840 delete arg1;
5841 }
5842 {
5843 if (temp2)
5844 delete arg2;
5845 }
5846 {
5847 if (temp3)
5848 delete arg3;
5849 }
5850 return resultobj;
5851 fail:
5852 {
5853 if (temp1)
5854 delete arg1;
5855 }
5856 {
5857 if (temp2)
5858 delete arg2;
5859 }
5860 {
5861 if (temp3)
5862 delete arg3;
5863 }
5864 return NULL;
5865 }
5866
5867
5868 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj = 0;
5870 wxString *arg1 = 0 ;
5871 wxString *arg2 = 0 ;
5872 wxString const &arg3_defvalue = wxPyEmptyString ;
5873 wxString *arg3 = (wxString *) &arg3_defvalue ;
5874 wxWindow *arg4 = (wxWindow *) NULL ;
5875 wxString result;
5876 bool temp1 = false ;
5877 bool temp2 = false ;
5878 bool temp3 = false ;
5879 void *argp4 = 0 ;
5880 int res4 = 0 ;
5881 PyObject * obj0 = 0 ;
5882 PyObject * obj1 = 0 ;
5883 PyObject * obj2 = 0 ;
5884 PyObject * obj3 = 0 ;
5885 char * kwnames[] = {
5886 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5887 };
5888
5889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5890 {
5891 arg1 = wxString_in_helper(obj0);
5892 if (arg1 == NULL) SWIG_fail;
5893 temp1 = true;
5894 }
5895 {
5896 arg2 = wxString_in_helper(obj1);
5897 if (arg2 == NULL) SWIG_fail;
5898 temp2 = true;
5899 }
5900 if (obj2) {
5901 {
5902 arg3 = wxString_in_helper(obj2);
5903 if (arg3 == NULL) SWIG_fail;
5904 temp3 = true;
5905 }
5906 }
5907 if (obj3) {
5908 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5909 if (!SWIG_IsOK(res4)) {
5910 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5911 }
5912 arg4 = reinterpret_cast< wxWindow * >(argp4);
5913 }
5914 {
5915 if (!wxPyCheckForApp()) SWIG_fail;
5916 PyThreadState* __tstate = wxPyBeginAllowThreads();
5917 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5918 wxPyEndAllowThreads(__tstate);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 {
5922 #if wxUSE_UNICODE
5923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5924 #else
5925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5926 #endif
5927 }
5928 {
5929 if (temp1)
5930 delete arg1;
5931 }
5932 {
5933 if (temp2)
5934 delete arg2;
5935 }
5936 {
5937 if (temp3)
5938 delete arg3;
5939 }
5940 return resultobj;
5941 fail:
5942 {
5943 if (temp1)
5944 delete arg1;
5945 }
5946 {
5947 if (temp2)
5948 delete arg2;
5949 }
5950 {
5951 if (temp3)
5952 delete arg3;
5953 }
5954 return NULL;
5955 }
5956
5957
5958 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5959 PyObject *resultobj = 0;
5960 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5961 wxString *arg1 = (wxString *) &arg1_defvalue ;
5962 wxString const &arg2_defvalue = wxPyEmptyString ;
5963 wxString *arg2 = (wxString *) &arg2_defvalue ;
5964 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5965 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5966 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5967 wxWindow *arg5 = (wxWindow *) NULL ;
5968 wxString result;
5969 bool temp1 = false ;
5970 bool temp2 = false ;
5971 long val3 ;
5972 int ecode3 = 0 ;
5973 wxPoint temp4 ;
5974 void *argp5 = 0 ;
5975 int res5 = 0 ;
5976 PyObject * obj0 = 0 ;
5977 PyObject * obj1 = 0 ;
5978 PyObject * obj2 = 0 ;
5979 PyObject * obj3 = 0 ;
5980 PyObject * obj4 = 0 ;
5981 char * kwnames[] = {
5982 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5983 };
5984
5985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5986 if (obj0) {
5987 {
5988 arg1 = wxString_in_helper(obj0);
5989 if (arg1 == NULL) SWIG_fail;
5990 temp1 = true;
5991 }
5992 }
5993 if (obj1) {
5994 {
5995 arg2 = wxString_in_helper(obj1);
5996 if (arg2 == NULL) SWIG_fail;
5997 temp2 = true;
5998 }
5999 }
6000 if (obj2) {
6001 ecode3 = SWIG_AsVal_long(obj2, &val3);
6002 if (!SWIG_IsOK(ecode3)) {
6003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
6004 }
6005 arg3 = static_cast< long >(val3);
6006 }
6007 if (obj3) {
6008 {
6009 arg4 = &temp4;
6010 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
6011 }
6012 }
6013 if (obj4) {
6014 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6015 if (!SWIG_IsOK(res5)) {
6016 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
6017 }
6018 arg5 = reinterpret_cast< wxWindow * >(argp5);
6019 }
6020 {
6021 if (!wxPyCheckForApp()) SWIG_fail;
6022 PyThreadState* __tstate = wxPyBeginAllowThreads();
6023 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
6024 wxPyEndAllowThreads(__tstate);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 {
6028 #if wxUSE_UNICODE
6029 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6030 #else
6031 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6032 #endif
6033 }
6034 {
6035 if (temp1)
6036 delete arg1;
6037 }
6038 {
6039 if (temp2)
6040 delete arg2;
6041 }
6042 return resultobj;
6043 fail:
6044 {
6045 if (temp1)
6046 delete arg1;
6047 }
6048 {
6049 if (temp2)
6050 delete arg2;
6051 }
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6057 PyObject *resultobj = 0;
6058 wxString *arg1 = 0 ;
6059 wxString const &arg2_defvalue = wxPyEmptyString ;
6060 wxString *arg2 = (wxString *) &arg2_defvalue ;
6061 wxString const &arg3_defvalue = wxPyEmptyString ;
6062 wxString *arg3 = (wxString *) &arg3_defvalue ;
6063 wxWindow *arg4 = (wxWindow *) NULL ;
6064 int arg5 = (int) -1 ;
6065 int arg6 = (int) -1 ;
6066 bool arg7 = (bool) true ;
6067 wxString result;
6068 bool temp1 = false ;
6069 bool temp2 = false ;
6070 bool temp3 = false ;
6071 void *argp4 = 0 ;
6072 int res4 = 0 ;
6073 int val5 ;
6074 int ecode5 = 0 ;
6075 int val6 ;
6076 int ecode6 = 0 ;
6077 bool val7 ;
6078 int ecode7 = 0 ;
6079 PyObject * obj0 = 0 ;
6080 PyObject * obj1 = 0 ;
6081 PyObject * obj2 = 0 ;
6082 PyObject * obj3 = 0 ;
6083 PyObject * obj4 = 0 ;
6084 PyObject * obj5 = 0 ;
6085 PyObject * obj6 = 0 ;
6086 char * kwnames[] = {
6087 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6088 };
6089
6090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6091 {
6092 arg1 = wxString_in_helper(obj0);
6093 if (arg1 == NULL) SWIG_fail;
6094 temp1 = true;
6095 }
6096 if (obj1) {
6097 {
6098 arg2 = wxString_in_helper(obj1);
6099 if (arg2 == NULL) SWIG_fail;
6100 temp2 = true;
6101 }
6102 }
6103 if (obj2) {
6104 {
6105 arg3 = wxString_in_helper(obj2);
6106 if (arg3 == NULL) SWIG_fail;
6107 temp3 = true;
6108 }
6109 }
6110 if (obj3) {
6111 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6112 if (!SWIG_IsOK(res4)) {
6113 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6114 }
6115 arg4 = reinterpret_cast< wxWindow * >(argp4);
6116 }
6117 if (obj4) {
6118 ecode5 = SWIG_AsVal_int(obj4, &val5);
6119 if (!SWIG_IsOK(ecode5)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6121 }
6122 arg5 = static_cast< int >(val5);
6123 }
6124 if (obj5) {
6125 ecode6 = SWIG_AsVal_int(obj5, &val6);
6126 if (!SWIG_IsOK(ecode6)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6128 }
6129 arg6 = static_cast< int >(val6);
6130 }
6131 if (obj6) {
6132 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6133 if (!SWIG_IsOK(ecode7)) {
6134 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6135 }
6136 arg7 = static_cast< bool >(val7);
6137 }
6138 {
6139 if (!wxPyCheckForApp()) SWIG_fail;
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6142 wxPyEndAllowThreads(__tstate);
6143 if (PyErr_Occurred()) SWIG_fail;
6144 }
6145 {
6146 #if wxUSE_UNICODE
6147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6148 #else
6149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6150 #endif
6151 }
6152 {
6153 if (temp1)
6154 delete arg1;
6155 }
6156 {
6157 if (temp2)
6158 delete arg2;
6159 }
6160 {
6161 if (temp3)
6162 delete arg3;
6163 }
6164 return resultobj;
6165 fail:
6166 {
6167 if (temp1)
6168 delete arg1;
6169 }
6170 {
6171 if (temp2)
6172 delete arg2;
6173 }
6174 {
6175 if (temp3)
6176 delete arg3;
6177 }
6178 return NULL;
6179 }
6180
6181
6182 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj = 0;
6184 wxString *arg1 = 0 ;
6185 wxString const &arg2_defvalue = wxPyEmptyString ;
6186 wxString *arg2 = (wxString *) &arg2_defvalue ;
6187 wxString const &arg3_defvalue = wxPyEmptyString ;
6188 wxString *arg3 = (wxString *) &arg3_defvalue ;
6189 wxWindow *arg4 = (wxWindow *) NULL ;
6190 wxString result;
6191 bool temp1 = false ;
6192 bool temp2 = false ;
6193 bool temp3 = false ;
6194 void *argp4 = 0 ;
6195 int res4 = 0 ;
6196 PyObject * obj0 = 0 ;
6197 PyObject * obj1 = 0 ;
6198 PyObject * obj2 = 0 ;
6199 PyObject * obj3 = 0 ;
6200 char * kwnames[] = {
6201 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6202 };
6203
6204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6205 {
6206 arg1 = wxString_in_helper(obj0);
6207 if (arg1 == NULL) SWIG_fail;
6208 temp1 = true;
6209 }
6210 if (obj1) {
6211 {
6212 arg2 = wxString_in_helper(obj1);
6213 if (arg2 == NULL) SWIG_fail;
6214 temp2 = true;
6215 }
6216 }
6217 if (obj2) {
6218 {
6219 arg3 = wxString_in_helper(obj2);
6220 if (arg3 == NULL) SWIG_fail;
6221 temp3 = true;
6222 }
6223 }
6224 if (obj3) {
6225 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6226 if (!SWIG_IsOK(res4)) {
6227 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6228 }
6229 arg4 = reinterpret_cast< wxWindow * >(argp4);
6230 }
6231 {
6232 if (!wxPyCheckForApp()) SWIG_fail;
6233 PyThreadState* __tstate = wxPyBeginAllowThreads();
6234 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6235 wxPyEndAllowThreads(__tstate);
6236 if (PyErr_Occurred()) SWIG_fail;
6237 }
6238 {
6239 #if wxUSE_UNICODE
6240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6241 #else
6242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6243 #endif
6244 }
6245 {
6246 if (temp1)
6247 delete arg1;
6248 }
6249 {
6250 if (temp2)
6251 delete arg2;
6252 }
6253 {
6254 if (temp3)
6255 delete arg3;
6256 }
6257 return resultobj;
6258 fail:
6259 {
6260 if (temp1)
6261 delete arg1;
6262 }
6263 {
6264 if (temp2)
6265 delete arg2;
6266 }
6267 {
6268 if (temp3)
6269 delete arg3;
6270 }
6271 return NULL;
6272 }
6273
6274
6275 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6276 PyObject *resultobj = 0;
6277 wxString *arg1 = 0 ;
6278 wxString *arg2 = 0 ;
6279 int arg3 ;
6280 wxString *arg4 = (wxString *) 0 ;
6281 wxWindow *arg5 = (wxWindow *) NULL ;
6282 int arg6 = (int) -1 ;
6283 int arg7 = (int) -1 ;
6284 bool arg8 = (bool) true ;
6285 int arg9 = (int) 150 ;
6286 int arg10 = (int) 200 ;
6287 wxString result;
6288 bool temp1 = false ;
6289 bool temp2 = false ;
6290 void *argp5 = 0 ;
6291 int res5 = 0 ;
6292 int val6 ;
6293 int ecode6 = 0 ;
6294 int val7 ;
6295 int ecode7 = 0 ;
6296 bool val8 ;
6297 int ecode8 = 0 ;
6298 int val9 ;
6299 int ecode9 = 0 ;
6300 int val10 ;
6301 int ecode10 = 0 ;
6302 PyObject * obj0 = 0 ;
6303 PyObject * obj1 = 0 ;
6304 PyObject * obj2 = 0 ;
6305 PyObject * obj3 = 0 ;
6306 PyObject * obj4 = 0 ;
6307 PyObject * obj5 = 0 ;
6308 PyObject * obj6 = 0 ;
6309 PyObject * obj7 = 0 ;
6310 PyObject * obj8 = 0 ;
6311 char * kwnames[] = {
6312 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6313 };
6314
6315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6316 {
6317 arg1 = wxString_in_helper(obj0);
6318 if (arg1 == NULL) SWIG_fail;
6319 temp1 = true;
6320 }
6321 {
6322 arg2 = wxString_in_helper(obj1);
6323 if (arg2 == NULL) SWIG_fail;
6324 temp2 = true;
6325 }
6326 {
6327 arg3 = PyList_Size(obj2);
6328 arg4 = wxString_LIST_helper(obj2);
6329 if (arg4 == NULL) SWIG_fail;
6330 }
6331 if (obj3) {
6332 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6333 if (!SWIG_IsOK(res5)) {
6334 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6335 }
6336 arg5 = reinterpret_cast< wxWindow * >(argp5);
6337 }
6338 if (obj4) {
6339 ecode6 = SWIG_AsVal_int(obj4, &val6);
6340 if (!SWIG_IsOK(ecode6)) {
6341 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6342 }
6343 arg6 = static_cast< int >(val6);
6344 }
6345 if (obj5) {
6346 ecode7 = SWIG_AsVal_int(obj5, &val7);
6347 if (!SWIG_IsOK(ecode7)) {
6348 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6349 }
6350 arg7 = static_cast< int >(val7);
6351 }
6352 if (obj6) {
6353 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6354 if (!SWIG_IsOK(ecode8)) {
6355 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6356 }
6357 arg8 = static_cast< bool >(val8);
6358 }
6359 if (obj7) {
6360 ecode9 = SWIG_AsVal_int(obj7, &val9);
6361 if (!SWIG_IsOK(ecode9)) {
6362 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6363 }
6364 arg9 = static_cast< int >(val9);
6365 }
6366 if (obj8) {
6367 ecode10 = SWIG_AsVal_int(obj8, &val10);
6368 if (!SWIG_IsOK(ecode10)) {
6369 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6370 }
6371 arg10 = static_cast< int >(val10);
6372 }
6373 {
6374 if (!wxPyCheckForApp()) SWIG_fail;
6375 PyThreadState* __tstate = wxPyBeginAllowThreads();
6376 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6377 wxPyEndAllowThreads(__tstate);
6378 if (PyErr_Occurred()) SWIG_fail;
6379 }
6380 {
6381 #if wxUSE_UNICODE
6382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6383 #else
6384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6385 #endif
6386 }
6387 {
6388 if (temp1)
6389 delete arg1;
6390 }
6391 {
6392 if (temp2)
6393 delete arg2;
6394 }
6395 {
6396 if (arg4) delete [] arg4;
6397 }
6398 return resultobj;
6399 fail:
6400 {
6401 if (temp1)
6402 delete arg1;
6403 }
6404 {
6405 if (temp2)
6406 delete arg2;
6407 }
6408 {
6409 if (arg4) delete [] arg4;
6410 }
6411 return NULL;
6412 }
6413
6414
6415 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6416 PyObject *resultobj = 0;
6417 wxString *arg1 = 0 ;
6418 wxString *arg2 = 0 ;
6419 int arg3 ;
6420 wxString *arg4 = (wxString *) 0 ;
6421 wxWindow *arg5 = (wxWindow *) NULL ;
6422 int arg6 = (int) -1 ;
6423 int arg7 = (int) -1 ;
6424 bool arg8 = (bool) true ;
6425 int arg9 = (int) 150 ;
6426 int arg10 = (int) 200 ;
6427 int result;
6428 bool temp1 = false ;
6429 bool temp2 = false ;
6430 void *argp5 = 0 ;
6431 int res5 = 0 ;
6432 int val6 ;
6433 int ecode6 = 0 ;
6434 int val7 ;
6435 int ecode7 = 0 ;
6436 bool val8 ;
6437 int ecode8 = 0 ;
6438 int val9 ;
6439 int ecode9 = 0 ;
6440 int val10 ;
6441 int ecode10 = 0 ;
6442 PyObject * obj0 = 0 ;
6443 PyObject * obj1 = 0 ;
6444 PyObject * obj2 = 0 ;
6445 PyObject * obj3 = 0 ;
6446 PyObject * obj4 = 0 ;
6447 PyObject * obj5 = 0 ;
6448 PyObject * obj6 = 0 ;
6449 PyObject * obj7 = 0 ;
6450 PyObject * obj8 = 0 ;
6451 char * kwnames[] = {
6452 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6453 };
6454
6455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6456 {
6457 arg1 = wxString_in_helper(obj0);
6458 if (arg1 == NULL) SWIG_fail;
6459 temp1 = true;
6460 }
6461 {
6462 arg2 = wxString_in_helper(obj1);
6463 if (arg2 == NULL) SWIG_fail;
6464 temp2 = true;
6465 }
6466 {
6467 arg3 = PyList_Size(obj2);
6468 arg4 = wxString_LIST_helper(obj2);
6469 if (arg4 == NULL) SWIG_fail;
6470 }
6471 if (obj3) {
6472 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6473 if (!SWIG_IsOK(res5)) {
6474 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6475 }
6476 arg5 = reinterpret_cast< wxWindow * >(argp5);
6477 }
6478 if (obj4) {
6479 ecode6 = SWIG_AsVal_int(obj4, &val6);
6480 if (!SWIG_IsOK(ecode6)) {
6481 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6482 }
6483 arg6 = static_cast< int >(val6);
6484 }
6485 if (obj5) {
6486 ecode7 = SWIG_AsVal_int(obj5, &val7);
6487 if (!SWIG_IsOK(ecode7)) {
6488 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6489 }
6490 arg7 = static_cast< int >(val7);
6491 }
6492 if (obj6) {
6493 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6494 if (!SWIG_IsOK(ecode8)) {
6495 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6496 }
6497 arg8 = static_cast< bool >(val8);
6498 }
6499 if (obj7) {
6500 ecode9 = SWIG_AsVal_int(obj7, &val9);
6501 if (!SWIG_IsOK(ecode9)) {
6502 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6503 }
6504 arg9 = static_cast< int >(val9);
6505 }
6506 if (obj8) {
6507 ecode10 = SWIG_AsVal_int(obj8, &val10);
6508 if (!SWIG_IsOK(ecode10)) {
6509 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6510 }
6511 arg10 = static_cast< int >(val10);
6512 }
6513 {
6514 if (!wxPyCheckForApp()) SWIG_fail;
6515 PyThreadState* __tstate = wxPyBeginAllowThreads();
6516 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6517 wxPyEndAllowThreads(__tstate);
6518 if (PyErr_Occurred()) SWIG_fail;
6519 }
6520 resultobj = SWIG_From_int(static_cast< int >(result));
6521 {
6522 if (temp1)
6523 delete arg1;
6524 }
6525 {
6526 if (temp2)
6527 delete arg2;
6528 }
6529 {
6530 if (arg4) delete [] arg4;
6531 }
6532 return resultobj;
6533 fail:
6534 {
6535 if (temp1)
6536 delete arg1;
6537 }
6538 {
6539 if (temp2)
6540 delete arg2;
6541 }
6542 {
6543 if (arg4) delete [] arg4;
6544 }
6545 return NULL;
6546 }
6547
6548
6549 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6550 PyObject *resultobj = 0;
6551 wxString *arg1 = 0 ;
6552 wxString const &arg2_defvalue = wxPyEmptyString ;
6553 wxString *arg2 = (wxString *) &arg2_defvalue ;
6554 int arg3 = (int) wxOK|wxCENTRE ;
6555 wxWindow *arg4 = (wxWindow *) NULL ;
6556 int arg5 = (int) -1 ;
6557 int arg6 = (int) -1 ;
6558 int result;
6559 bool temp1 = false ;
6560 bool temp2 = false ;
6561 int val3 ;
6562 int ecode3 = 0 ;
6563 void *argp4 = 0 ;
6564 int res4 = 0 ;
6565 int val5 ;
6566 int ecode5 = 0 ;
6567 int val6 ;
6568 int ecode6 = 0 ;
6569 PyObject * obj0 = 0 ;
6570 PyObject * obj1 = 0 ;
6571 PyObject * obj2 = 0 ;
6572 PyObject * obj3 = 0 ;
6573 PyObject * obj4 = 0 ;
6574 PyObject * obj5 = 0 ;
6575 char * kwnames[] = {
6576 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6577 };
6578
6579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6580 {
6581 arg1 = wxString_in_helper(obj0);
6582 if (arg1 == NULL) SWIG_fail;
6583 temp1 = true;
6584 }
6585 if (obj1) {
6586 {
6587 arg2 = wxString_in_helper(obj1);
6588 if (arg2 == NULL) SWIG_fail;
6589 temp2 = true;
6590 }
6591 }
6592 if (obj2) {
6593 ecode3 = SWIG_AsVal_int(obj2, &val3);
6594 if (!SWIG_IsOK(ecode3)) {
6595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6596 }
6597 arg3 = static_cast< int >(val3);
6598 }
6599 if (obj3) {
6600 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6601 if (!SWIG_IsOK(res4)) {
6602 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6603 }
6604 arg4 = reinterpret_cast< wxWindow * >(argp4);
6605 }
6606 if (obj4) {
6607 ecode5 = SWIG_AsVal_int(obj4, &val5);
6608 if (!SWIG_IsOK(ecode5)) {
6609 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6610 }
6611 arg5 = static_cast< int >(val5);
6612 }
6613 if (obj5) {
6614 ecode6 = SWIG_AsVal_int(obj5, &val6);
6615 if (!SWIG_IsOK(ecode6)) {
6616 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6617 }
6618 arg6 = static_cast< int >(val6);
6619 }
6620 {
6621 if (!wxPyCheckForApp()) SWIG_fail;
6622 PyThreadState* __tstate = wxPyBeginAllowThreads();
6623 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6624 wxPyEndAllowThreads(__tstate);
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_From_int(static_cast< int >(result));
6628 {
6629 if (temp1)
6630 delete arg1;
6631 }
6632 {
6633 if (temp2)
6634 delete arg2;
6635 }
6636 return resultobj;
6637 fail:
6638 {
6639 if (temp1)
6640 delete arg1;
6641 }
6642 {
6643 if (temp2)
6644 delete arg2;
6645 }
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj = 0;
6652 wxString *arg1 = 0 ;
6653 wxString *arg2 = 0 ;
6654 wxString *arg3 = 0 ;
6655 long arg4 ;
6656 long arg5 = (long) 0 ;
6657 long arg6 = (long) 100 ;
6658 wxWindow *arg7 = (wxWindow *) NULL ;
6659 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6660 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6661 long result;
6662 bool temp1 = false ;
6663 bool temp2 = false ;
6664 bool temp3 = false ;
6665 long val4 ;
6666 int ecode4 = 0 ;
6667 long val5 ;
6668 int ecode5 = 0 ;
6669 long val6 ;
6670 int ecode6 = 0 ;
6671 void *argp7 = 0 ;
6672 int res7 = 0 ;
6673 wxPoint temp8 ;
6674 PyObject * obj0 = 0 ;
6675 PyObject * obj1 = 0 ;
6676 PyObject * obj2 = 0 ;
6677 PyObject * obj3 = 0 ;
6678 PyObject * obj4 = 0 ;
6679 PyObject * obj5 = 0 ;
6680 PyObject * obj6 = 0 ;
6681 PyObject * obj7 = 0 ;
6682 char * kwnames[] = {
6683 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6684 };
6685
6686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6687 {
6688 arg1 = wxString_in_helper(obj0);
6689 if (arg1 == NULL) SWIG_fail;
6690 temp1 = true;
6691 }
6692 {
6693 arg2 = wxString_in_helper(obj1);
6694 if (arg2 == NULL) SWIG_fail;
6695 temp2 = true;
6696 }
6697 {
6698 arg3 = wxString_in_helper(obj2);
6699 if (arg3 == NULL) SWIG_fail;
6700 temp3 = true;
6701 }
6702 ecode4 = SWIG_AsVal_long(obj3, &val4);
6703 if (!SWIG_IsOK(ecode4)) {
6704 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6705 }
6706 arg4 = static_cast< long >(val4);
6707 if (obj4) {
6708 ecode5 = SWIG_AsVal_long(obj4, &val5);
6709 if (!SWIG_IsOK(ecode5)) {
6710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6711 }
6712 arg5 = static_cast< long >(val5);
6713 }
6714 if (obj5) {
6715 ecode6 = SWIG_AsVal_long(obj5, &val6);
6716 if (!SWIG_IsOK(ecode6)) {
6717 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6718 }
6719 arg6 = static_cast< long >(val6);
6720 }
6721 if (obj6) {
6722 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6723 if (!SWIG_IsOK(res7)) {
6724 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6725 }
6726 arg7 = reinterpret_cast< wxWindow * >(argp7);
6727 }
6728 if (obj7) {
6729 {
6730 arg8 = &temp8;
6731 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6732 }
6733 }
6734 {
6735 if (!wxPyCheckForApp()) SWIG_fail;
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 resultobj = SWIG_From_long(static_cast< long >(result));
6742 {
6743 if (temp1)
6744 delete arg1;
6745 }
6746 {
6747 if (temp2)
6748 delete arg2;
6749 }
6750 {
6751 if (temp3)
6752 delete arg3;
6753 }
6754 return resultobj;
6755 fail:
6756 {
6757 if (temp1)
6758 delete arg1;
6759 }
6760 {
6761 if (temp2)
6762 delete arg2;
6763 }
6764 {
6765 if (temp3)
6766 delete arg3;
6767 }
6768 return NULL;
6769 }
6770
6771
6772 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6773 PyObject *resultobj = 0;
6774 bool result;
6775
6776 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6777 {
6778 if (!wxPyCheckForApp()) SWIG_fail;
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = (bool)wxColourDisplay();
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 {
6785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6786 }
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6794 PyObject *resultobj = 0;
6795 int result;
6796
6797 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6798 {
6799 if (!wxPyCheckForApp()) SWIG_fail;
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 result = (int)wxDisplayDepth();
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_From_int(static_cast< int >(result));
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 int result;
6815
6816 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6817 {
6818 if (!wxPyCheckForApp()) SWIG_fail;
6819 PyThreadState* __tstate = wxPyBeginAllowThreads();
6820 result = (int)wxGetDisplayDepth();
6821 wxPyEndAllowThreads(__tstate);
6822 if (PyErr_Occurred()) SWIG_fail;
6823 }
6824 resultobj = SWIG_From_int(static_cast< int >(result));
6825 return resultobj;
6826 fail:
6827 return NULL;
6828 }
6829
6830
6831 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6832 PyObject *resultobj = 0;
6833 int *arg1 = (int *) 0 ;
6834 int *arg2 = (int *) 0 ;
6835 int temp1 ;
6836 int res1 = SWIG_TMPOBJ ;
6837 int temp2 ;
6838 int res2 = SWIG_TMPOBJ ;
6839
6840 arg1 = &temp1;
6841 arg2 = &temp2;
6842 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6843 {
6844 if (!wxPyCheckForApp()) SWIG_fail;
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 wxDisplaySize(arg1,arg2);
6847 wxPyEndAllowThreads(__tstate);
6848 if (PyErr_Occurred()) SWIG_fail;
6849 }
6850 resultobj = SWIG_Py_Void();
6851 if (SWIG_IsTmpObj(res1)) {
6852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6853 } else {
6854 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6856 }
6857 if (SWIG_IsTmpObj(res2)) {
6858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6859 } else {
6860 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6862 }
6863 return resultobj;
6864 fail:
6865 return NULL;
6866 }
6867
6868
6869 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6870 PyObject *resultobj = 0;
6871 wxSize result;
6872
6873 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6874 {
6875 if (!wxPyCheckForApp()) SWIG_fail;
6876 PyThreadState* __tstate = wxPyBeginAllowThreads();
6877 result = wxGetDisplaySize();
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6889 PyObject *resultobj = 0;
6890 int *arg1 = (int *) 0 ;
6891 int *arg2 = (int *) 0 ;
6892 int temp1 ;
6893 int res1 = SWIG_TMPOBJ ;
6894 int temp2 ;
6895 int res2 = SWIG_TMPOBJ ;
6896
6897 arg1 = &temp1;
6898 arg2 = &temp2;
6899 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6900 {
6901 if (!wxPyCheckForApp()) SWIG_fail;
6902 PyThreadState* __tstate = wxPyBeginAllowThreads();
6903 wxDisplaySizeMM(arg1,arg2);
6904 wxPyEndAllowThreads(__tstate);
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 resultobj = SWIG_Py_Void();
6908 if (SWIG_IsTmpObj(res1)) {
6909 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6910 } else {
6911 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6912 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6913 }
6914 if (SWIG_IsTmpObj(res2)) {
6915 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6916 } else {
6917 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6918 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6919 }
6920 return resultobj;
6921 fail:
6922 return NULL;
6923 }
6924
6925
6926 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6927 PyObject *resultobj = 0;
6928 wxSize result;
6929
6930 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6931 {
6932 if (!wxPyCheckForApp()) SWIG_fail;
6933 PyThreadState* __tstate = wxPyBeginAllowThreads();
6934 result = wxGetDisplaySizeMM();
6935 wxPyEndAllowThreads(__tstate);
6936 if (PyErr_Occurred()) SWIG_fail;
6937 }
6938 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6939 return resultobj;
6940 fail:
6941 return NULL;
6942 }
6943
6944
6945 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6946 PyObject *resultobj = 0;
6947 int *arg1 = (int *) 0 ;
6948 int *arg2 = (int *) 0 ;
6949 int *arg3 = (int *) 0 ;
6950 int *arg4 = (int *) 0 ;
6951 int temp1 ;
6952 int res1 = SWIG_TMPOBJ ;
6953 int temp2 ;
6954 int res2 = SWIG_TMPOBJ ;
6955 int temp3 ;
6956 int res3 = SWIG_TMPOBJ ;
6957 int temp4 ;
6958 int res4 = SWIG_TMPOBJ ;
6959
6960 arg1 = &temp1;
6961 arg2 = &temp2;
6962 arg3 = &temp3;
6963 arg4 = &temp4;
6964 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6965 {
6966 if (!wxPyCheckForApp()) SWIG_fail;
6967 PyThreadState* __tstate = wxPyBeginAllowThreads();
6968 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6969 wxPyEndAllowThreads(__tstate);
6970 if (PyErr_Occurred()) SWIG_fail;
6971 }
6972 resultobj = SWIG_Py_Void();
6973 if (SWIG_IsTmpObj(res1)) {
6974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6975 } else {
6976 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6978 }
6979 if (SWIG_IsTmpObj(res2)) {
6980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6981 } else {
6982 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6984 }
6985 if (SWIG_IsTmpObj(res3)) {
6986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6987 } else {
6988 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6990 }
6991 if (SWIG_IsTmpObj(res4)) {
6992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6993 } else {
6994 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6996 }
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7004 PyObject *resultobj = 0;
7005 wxRect result;
7006
7007 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
7008 {
7009 if (!wxPyCheckForApp()) SWIG_fail;
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 result = wxGetClientDisplayRect();
7012 wxPyEndAllowThreads(__tstate);
7013 if (PyErr_Occurred()) SWIG_fail;
7014 }
7015 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7016 return resultobj;
7017 fail:
7018 return NULL;
7019 }
7020
7021
7022 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7023 PyObject *resultobj = 0;
7024 wxCursor *arg1 = 0 ;
7025 void *argp1 = 0 ;
7026 int res1 = 0 ;
7027 PyObject * obj0 = 0 ;
7028 char * kwnames[] = {
7029 (char *) "cursor", NULL
7030 };
7031
7032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
7033 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
7034 if (!SWIG_IsOK(res1)) {
7035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7036 }
7037 if (!argp1) {
7038 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
7039 }
7040 arg1 = reinterpret_cast< wxCursor * >(argp1);
7041 {
7042 if (!wxPyCheckForApp()) SWIG_fail;
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 wxSetCursor(*arg1);
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 resultobj = SWIG_Py_Void();
7049 return resultobj;
7050 fail:
7051 return NULL;
7052 }
7053
7054
7055 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7056 PyObject *resultobj = 0;
7057 void *result = 0 ;
7058
7059 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
7060 {
7061 if (!wxPyCheckForApp()) SWIG_fail;
7062 PyThreadState* __tstate = wxPyBeginAllowThreads();
7063 result = (void *)wxGetXDisplay();
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
7068 return resultobj;
7069 fail:
7070 return NULL;
7071 }
7072
7073
7074 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7075 PyObject *resultobj = 0;
7076 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
7077 void *argp1 = 0 ;
7078 int res1 = 0 ;
7079 PyObject * obj0 = 0 ;
7080 char * kwnames[] = {
7081 (char *) "cursor", NULL
7082 };
7083
7084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7085 if (obj0) {
7086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7089 }
7090 arg1 = reinterpret_cast< wxCursor * >(argp1);
7091 }
7092 {
7093 if (!wxPyCheckForApp()) SWIG_fail;
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 wxBeginBusyCursor(arg1);
7096 wxPyEndAllowThreads(__tstate);
7097 if (PyErr_Occurred()) SWIG_fail;
7098 }
7099 resultobj = SWIG_Py_Void();
7100 return resultobj;
7101 fail:
7102 return NULL;
7103 }
7104
7105
7106 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7107 PyObject *resultobj = 0;
7108 wxPoint result;
7109
7110 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7111 {
7112 if (!wxPyCheckForApp()) SWIG_fail;
7113 PyThreadState* __tstate = wxPyBeginAllowThreads();
7114 result = wxGetMousePosition();
7115 wxPyEndAllowThreads(__tstate);
7116 if (PyErr_Occurred()) SWIG_fail;
7117 }
7118 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7119 return resultobj;
7120 fail:
7121 return NULL;
7122 }
7123
7124
7125 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7126 PyObject *resultobj = 0;
7127 wxWindow *result = 0 ;
7128
7129 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7130 {
7131 if (!wxPyCheckForApp()) SWIG_fail;
7132 PyThreadState* __tstate = wxPyBeginAllowThreads();
7133 result = (wxWindow *)FindWindowAtPointer();
7134 wxPyEndAllowThreads(__tstate);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 {
7138 resultobj = wxPyMake_wxObject(result, 0);
7139 }
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7147 PyObject *resultobj = 0;
7148 wxWindow *result = 0 ;
7149
7150 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7151 {
7152 if (!wxPyCheckForApp()) SWIG_fail;
7153 PyThreadState* __tstate = wxPyBeginAllowThreads();
7154 result = (wxWindow *)wxGetActiveWindow();
7155 wxPyEndAllowThreads(__tstate);
7156 if (PyErr_Occurred()) SWIG_fail;
7157 }
7158 {
7159 resultobj = wxPyMake_wxObject(result, 0);
7160 }
7161 return resultobj;
7162 fail:
7163 return NULL;
7164 }
7165
7166
7167 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7168 PyObject *resultobj = 0;
7169 wxPoint *arg1 = 0 ;
7170 wxWindow *result = 0 ;
7171 wxPoint temp1 ;
7172 PyObject * obj0 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "pt", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7178 {
7179 arg1 = &temp1;
7180 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7181 }
7182 {
7183 if (!wxPyCheckForApp()) SWIG_fail;
7184 PyThreadState* __tstate = wxPyBeginAllowThreads();
7185 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7186 wxPyEndAllowThreads(__tstate);
7187 if (PyErr_Occurred()) SWIG_fail;
7188 }
7189 {
7190 resultobj = wxPyMake_wxObject(result, 0);
7191 }
7192 return resultobj;
7193 fail:
7194 return NULL;
7195 }
7196
7197
7198 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7199 PyObject *resultobj = 0;
7200 wxPoint *arg1 = 0 ;
7201 wxWindow *result = 0 ;
7202 wxPoint temp1 ;
7203 PyObject * obj0 = 0 ;
7204 char * kwnames[] = {
7205 (char *) "pt", NULL
7206 };
7207
7208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7209 {
7210 arg1 = &temp1;
7211 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7212 }
7213 {
7214 if (!wxPyCheckForApp()) SWIG_fail;
7215 PyThreadState* __tstate = wxPyBeginAllowThreads();
7216 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7217 wxPyEndAllowThreads(__tstate);
7218 if (PyErr_Occurred()) SWIG_fail;
7219 }
7220 {
7221 resultobj = wxPyMake_wxObject(result, 0);
7222 }
7223 return resultobj;
7224 fail:
7225 return NULL;
7226 }
7227
7228
7229 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7230 PyObject *resultobj = 0;
7231 wxWindow *arg1 = (wxWindow *) 0 ;
7232 wxWindow *result = 0 ;
7233 void *argp1 = 0 ;
7234 int res1 = 0 ;
7235 PyObject * obj0 = 0 ;
7236 char * kwnames[] = {
7237 (char *) "win", NULL
7238 };
7239
7240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7242 if (!SWIG_IsOK(res1)) {
7243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7244 }
7245 arg1 = reinterpret_cast< wxWindow * >(argp1);
7246 {
7247 if (!wxPyCheckForApp()) SWIG_fail;
7248 PyThreadState* __tstate = wxPyBeginAllowThreads();
7249 result = (wxWindow *)wxGetTopLevelParent(arg1);
7250 wxPyEndAllowThreads(__tstate);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 {
7254 resultobj = wxPyMake_wxObject(result, 0);
7255 }
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj = 0;
7264 wxString *arg1 = 0 ;
7265 bool result;
7266 bool temp1 = false ;
7267 PyObject * obj0 = 0 ;
7268 char * kwnames[] = {
7269 (char *) "url", NULL
7270 };
7271
7272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7273 {
7274 arg1 = wxString_in_helper(obj0);
7275 if (arg1 == NULL) SWIG_fail;
7276 temp1 = true;
7277 }
7278 {
7279 PyThreadState* __tstate = wxPyBeginAllowThreads();
7280 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7281 wxPyEndAllowThreads(__tstate);
7282 if (PyErr_Occurred()) SWIG_fail;
7283 }
7284 {
7285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7286 }
7287 {
7288 if (temp1)
7289 delete arg1;
7290 }
7291 return resultobj;
7292 fail:
7293 {
7294 if (temp1)
7295 delete arg1;
7296 }
7297 return NULL;
7298 }
7299
7300
7301 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7302 PyObject *resultobj = 0;
7303 wxKeyCode arg1 ;
7304 bool result;
7305 int val1 ;
7306 int ecode1 = 0 ;
7307 PyObject * obj0 = 0 ;
7308 char * kwnames[] = {
7309 (char *) "key", NULL
7310 };
7311
7312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7313 ecode1 = SWIG_AsVal_int(obj0, &val1);
7314 if (!SWIG_IsOK(ecode1)) {
7315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7316 }
7317 arg1 = static_cast< wxKeyCode >(val1);
7318 {
7319 if (!wxPyCheckForApp()) SWIG_fail;
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 result = (bool)wxGetKeyState(arg1);
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 {
7326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7327 }
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7335 PyObject *resultobj = 0;
7336 wxMouseState *result = 0 ;
7337
7338 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7339 {
7340 PyThreadState* __tstate = wxPyBeginAllowThreads();
7341 result = (wxMouseState *)new wxMouseState();
7342 wxPyEndAllowThreads(__tstate);
7343 if (PyErr_Occurred()) SWIG_fail;
7344 }
7345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7346 return resultobj;
7347 fail:
7348 return NULL;
7349 }
7350
7351
7352 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7353 PyObject *resultobj = 0;
7354 wxMouseState *arg1 = (wxMouseState *) 0 ;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 PyObject *swig_obj[1] ;
7358
7359 if (!args) SWIG_fail;
7360 swig_obj[0] = args;
7361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7362 if (!SWIG_IsOK(res1)) {
7363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7364 }
7365 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7366 {
7367 PyThreadState* __tstate = wxPyBeginAllowThreads();
7368 delete arg1;
7369
7370 wxPyEndAllowThreads(__tstate);
7371 if (PyErr_Occurred()) SWIG_fail;
7372 }
7373 resultobj = SWIG_Py_Void();
7374 return resultobj;
7375 fail:
7376 return NULL;
7377 }
7378
7379
7380 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7381 PyObject *resultobj = 0;
7382 wxMouseState *arg1 = (wxMouseState *) 0 ;
7383 int result;
7384 void *argp1 = 0 ;
7385 int res1 = 0 ;
7386 PyObject *swig_obj[1] ;
7387
7388 if (!args) SWIG_fail;
7389 swig_obj[0] = args;
7390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7391 if (!SWIG_IsOK(res1)) {
7392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7393 }
7394 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7395 {
7396 PyThreadState* __tstate = wxPyBeginAllowThreads();
7397 result = (int)(arg1)->GetX();
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 resultobj = SWIG_From_int(static_cast< int >(result));
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7409 PyObject *resultobj = 0;
7410 wxMouseState *arg1 = (wxMouseState *) 0 ;
7411 int result;
7412 void *argp1 = 0 ;
7413 int res1 = 0 ;
7414 PyObject *swig_obj[1] ;
7415
7416 if (!args) SWIG_fail;
7417 swig_obj[0] = args;
7418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7419 if (!SWIG_IsOK(res1)) {
7420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7421 }
7422 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7423 {
7424 PyThreadState* __tstate = wxPyBeginAllowThreads();
7425 result = (int)(arg1)->GetY();
7426 wxPyEndAllowThreads(__tstate);
7427 if (PyErr_Occurred()) SWIG_fail;
7428 }
7429 resultobj = SWIG_From_int(static_cast< int >(result));
7430 return resultobj;
7431 fail:
7432 return NULL;
7433 }
7434
7435
7436 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7437 PyObject *resultobj = 0;
7438 wxMouseState *arg1 = (wxMouseState *) 0 ;
7439 bool result;
7440 void *argp1 = 0 ;
7441 int res1 = 0 ;
7442 PyObject *swig_obj[1] ;
7443
7444 if (!args) SWIG_fail;
7445 swig_obj[0] = args;
7446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7447 if (!SWIG_IsOK(res1)) {
7448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7449 }
7450 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7451 {
7452 PyThreadState* __tstate = wxPyBeginAllowThreads();
7453 result = (bool)(arg1)->LeftDown();
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 {
7458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7459 }
7460 return resultobj;
7461 fail:
7462 return NULL;
7463 }
7464
7465
7466 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7467 PyObject *resultobj = 0;
7468 wxMouseState *arg1 = (wxMouseState *) 0 ;
7469 bool result;
7470 void *argp1 = 0 ;
7471 int res1 = 0 ;
7472 PyObject *swig_obj[1] ;
7473
7474 if (!args) SWIG_fail;
7475 swig_obj[0] = args;
7476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7477 if (!SWIG_IsOK(res1)) {
7478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7479 }
7480 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)(arg1)->MiddleDown();
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 {
7488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7489 }
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7497 PyObject *resultobj = 0;
7498 wxMouseState *arg1 = (wxMouseState *) 0 ;
7499 bool result;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 PyObject *swig_obj[1] ;
7503
7504 if (!args) SWIG_fail;
7505 swig_obj[0] = args;
7506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7507 if (!SWIG_IsOK(res1)) {
7508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7509 }
7510 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7511 {
7512 PyThreadState* __tstate = wxPyBeginAllowThreads();
7513 result = (bool)(arg1)->RightDown();
7514 wxPyEndAllowThreads(__tstate);
7515 if (PyErr_Occurred()) SWIG_fail;
7516 }
7517 {
7518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7519 }
7520 return resultobj;
7521 fail:
7522 return NULL;
7523 }
7524
7525
7526 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7527 PyObject *resultobj = 0;
7528 wxMouseState *arg1 = (wxMouseState *) 0 ;
7529 bool result;
7530 void *argp1 = 0 ;
7531 int res1 = 0 ;
7532 PyObject *swig_obj[1] ;
7533
7534 if (!args) SWIG_fail;
7535 swig_obj[0] = args;
7536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7537 if (!SWIG_IsOK(res1)) {
7538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7539 }
7540 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7541 {
7542 PyThreadState* __tstate = wxPyBeginAllowThreads();
7543 result = (bool)(arg1)->ControlDown();
7544 wxPyEndAllowThreads(__tstate);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 {
7548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7549 }
7550 return resultobj;
7551 fail:
7552 return NULL;
7553 }
7554
7555
7556 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7557 PyObject *resultobj = 0;
7558 wxMouseState *arg1 = (wxMouseState *) 0 ;
7559 bool result;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 PyObject *swig_obj[1] ;
7563
7564 if (!args) SWIG_fail;
7565 swig_obj[0] = args;
7566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7567 if (!SWIG_IsOK(res1)) {
7568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7569 }
7570 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7571 {
7572 PyThreadState* __tstate = wxPyBeginAllowThreads();
7573 result = (bool)(arg1)->ShiftDown();
7574 wxPyEndAllowThreads(__tstate);
7575 if (PyErr_Occurred()) SWIG_fail;
7576 }
7577 {
7578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7579 }
7580 return resultobj;
7581 fail:
7582 return NULL;
7583 }
7584
7585
7586 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7587 PyObject *resultobj = 0;
7588 wxMouseState *arg1 = (wxMouseState *) 0 ;
7589 bool result;
7590 void *argp1 = 0 ;
7591 int res1 = 0 ;
7592 PyObject *swig_obj[1] ;
7593
7594 if (!args) SWIG_fail;
7595 swig_obj[0] = args;
7596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7597 if (!SWIG_IsOK(res1)) {
7598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7599 }
7600 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7601 {
7602 PyThreadState* __tstate = wxPyBeginAllowThreads();
7603 result = (bool)(arg1)->AltDown();
7604 wxPyEndAllowThreads(__tstate);
7605 if (PyErr_Occurred()) SWIG_fail;
7606 }
7607 {
7608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7609 }
7610 return resultobj;
7611 fail:
7612 return NULL;
7613 }
7614
7615
7616 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7617 PyObject *resultobj = 0;
7618 wxMouseState *arg1 = (wxMouseState *) 0 ;
7619 bool result;
7620 void *argp1 = 0 ;
7621 int res1 = 0 ;
7622 PyObject *swig_obj[1] ;
7623
7624 if (!args) SWIG_fail;
7625 swig_obj[0] = args;
7626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7627 if (!SWIG_IsOK(res1)) {
7628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7629 }
7630 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7631 {
7632 PyThreadState* __tstate = wxPyBeginAllowThreads();
7633 result = (bool)(arg1)->MetaDown();
7634 wxPyEndAllowThreads(__tstate);
7635 if (PyErr_Occurred()) SWIG_fail;
7636 }
7637 {
7638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7639 }
7640 return resultobj;
7641 fail:
7642 return NULL;
7643 }
7644
7645
7646 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7647 PyObject *resultobj = 0;
7648 wxMouseState *arg1 = (wxMouseState *) 0 ;
7649 bool result;
7650 void *argp1 = 0 ;
7651 int res1 = 0 ;
7652 PyObject *swig_obj[1] ;
7653
7654 if (!args) SWIG_fail;
7655 swig_obj[0] = args;
7656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7657 if (!SWIG_IsOK(res1)) {
7658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7659 }
7660 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7661 {
7662 PyThreadState* __tstate = wxPyBeginAllowThreads();
7663 result = (bool)(arg1)->CmdDown();
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 {
7668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7669 }
7670 return resultobj;
7671 fail:
7672 return NULL;
7673 }
7674
7675
7676 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7677 PyObject *resultobj = 0;
7678 wxMouseState *arg1 = (wxMouseState *) 0 ;
7679 int arg2 ;
7680 void *argp1 = 0 ;
7681 int res1 = 0 ;
7682 int val2 ;
7683 int ecode2 = 0 ;
7684 PyObject * obj0 = 0 ;
7685 PyObject * obj1 = 0 ;
7686 char * kwnames[] = {
7687 (char *) "self",(char *) "x", NULL
7688 };
7689
7690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7692 if (!SWIG_IsOK(res1)) {
7693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7694 }
7695 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7696 ecode2 = SWIG_AsVal_int(obj1, &val2);
7697 if (!SWIG_IsOK(ecode2)) {
7698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7699 }
7700 arg2 = static_cast< int >(val2);
7701 {
7702 PyThreadState* __tstate = wxPyBeginAllowThreads();
7703 (arg1)->SetX(arg2);
7704 wxPyEndAllowThreads(__tstate);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 resultobj = SWIG_Py_Void();
7708 return resultobj;
7709 fail:
7710 return NULL;
7711 }
7712
7713
7714 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7715 PyObject *resultobj = 0;
7716 wxMouseState *arg1 = (wxMouseState *) 0 ;
7717 int arg2 ;
7718 void *argp1 = 0 ;
7719 int res1 = 0 ;
7720 int val2 ;
7721 int ecode2 = 0 ;
7722 PyObject * obj0 = 0 ;
7723 PyObject * obj1 = 0 ;
7724 char * kwnames[] = {
7725 (char *) "self",(char *) "y", NULL
7726 };
7727
7728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7730 if (!SWIG_IsOK(res1)) {
7731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7732 }
7733 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7734 ecode2 = SWIG_AsVal_int(obj1, &val2);
7735 if (!SWIG_IsOK(ecode2)) {
7736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7737 }
7738 arg2 = static_cast< int >(val2);
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 (arg1)->SetY(arg2);
7742 wxPyEndAllowThreads(__tstate);
7743 if (PyErr_Occurred()) SWIG_fail;
7744 }
7745 resultobj = SWIG_Py_Void();
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7753 PyObject *resultobj = 0;
7754 wxMouseState *arg1 = (wxMouseState *) 0 ;
7755 bool arg2 ;
7756 void *argp1 = 0 ;
7757 int res1 = 0 ;
7758 bool val2 ;
7759 int ecode2 = 0 ;
7760 PyObject * obj0 = 0 ;
7761 PyObject * obj1 = 0 ;
7762 char * kwnames[] = {
7763 (char *) "self",(char *) "down", NULL
7764 };
7765
7766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7768 if (!SWIG_IsOK(res1)) {
7769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7770 }
7771 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7773 if (!SWIG_IsOK(ecode2)) {
7774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7775 }
7776 arg2 = static_cast< bool >(val2);
7777 {
7778 PyThreadState* __tstate = wxPyBeginAllowThreads();
7779 (arg1)->SetLeftDown(arg2);
7780 wxPyEndAllowThreads(__tstate);
7781 if (PyErr_Occurred()) SWIG_fail;
7782 }
7783 resultobj = SWIG_Py_Void();
7784 return resultobj;
7785 fail:
7786 return NULL;
7787 }
7788
7789
7790 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj = 0;
7792 wxMouseState *arg1 = (wxMouseState *) 0 ;
7793 bool arg2 ;
7794 void *argp1 = 0 ;
7795 int res1 = 0 ;
7796 bool val2 ;
7797 int ecode2 = 0 ;
7798 PyObject * obj0 = 0 ;
7799 PyObject * obj1 = 0 ;
7800 char * kwnames[] = {
7801 (char *) "self",(char *) "down", NULL
7802 };
7803
7804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7806 if (!SWIG_IsOK(res1)) {
7807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7808 }
7809 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7810 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7811 if (!SWIG_IsOK(ecode2)) {
7812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7813 }
7814 arg2 = static_cast< bool >(val2);
7815 {
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 (arg1)->SetMiddleDown(arg2);
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 resultobj = SWIG_Py_Void();
7822 return resultobj;
7823 fail:
7824 return NULL;
7825 }
7826
7827
7828 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7829 PyObject *resultobj = 0;
7830 wxMouseState *arg1 = (wxMouseState *) 0 ;
7831 bool arg2 ;
7832 void *argp1 = 0 ;
7833 int res1 = 0 ;
7834 bool val2 ;
7835 int ecode2 = 0 ;
7836 PyObject * obj0 = 0 ;
7837 PyObject * obj1 = 0 ;
7838 char * kwnames[] = {
7839 (char *) "self",(char *) "down", NULL
7840 };
7841
7842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7844 if (!SWIG_IsOK(res1)) {
7845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7846 }
7847 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7849 if (!SWIG_IsOK(ecode2)) {
7850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7851 }
7852 arg2 = static_cast< bool >(val2);
7853 {
7854 PyThreadState* __tstate = wxPyBeginAllowThreads();
7855 (arg1)->SetRightDown(arg2);
7856 wxPyEndAllowThreads(__tstate);
7857 if (PyErr_Occurred()) SWIG_fail;
7858 }
7859 resultobj = SWIG_Py_Void();
7860 return resultobj;
7861 fail:
7862 return NULL;
7863 }
7864
7865
7866 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7867 PyObject *resultobj = 0;
7868 wxMouseState *arg1 = (wxMouseState *) 0 ;
7869 bool arg2 ;
7870 void *argp1 = 0 ;
7871 int res1 = 0 ;
7872 bool val2 ;
7873 int ecode2 = 0 ;
7874 PyObject * obj0 = 0 ;
7875 PyObject * obj1 = 0 ;
7876 char * kwnames[] = {
7877 (char *) "self",(char *) "down", NULL
7878 };
7879
7880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7882 if (!SWIG_IsOK(res1)) {
7883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7884 }
7885 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7886 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7887 if (!SWIG_IsOK(ecode2)) {
7888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7889 }
7890 arg2 = static_cast< bool >(val2);
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 (arg1)->SetControlDown(arg2);
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 resultobj = SWIG_Py_Void();
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7905 PyObject *resultobj = 0;
7906 wxMouseState *arg1 = (wxMouseState *) 0 ;
7907 bool arg2 ;
7908 void *argp1 = 0 ;
7909 int res1 = 0 ;
7910 bool val2 ;
7911 int ecode2 = 0 ;
7912 PyObject * obj0 = 0 ;
7913 PyObject * obj1 = 0 ;
7914 char * kwnames[] = {
7915 (char *) "self",(char *) "down", NULL
7916 };
7917
7918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7920 if (!SWIG_IsOK(res1)) {
7921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7922 }
7923 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7924 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7925 if (!SWIG_IsOK(ecode2)) {
7926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7927 }
7928 arg2 = static_cast< bool >(val2);
7929 {
7930 PyThreadState* __tstate = wxPyBeginAllowThreads();
7931 (arg1)->SetShiftDown(arg2);
7932 wxPyEndAllowThreads(__tstate);
7933 if (PyErr_Occurred()) SWIG_fail;
7934 }
7935 resultobj = SWIG_Py_Void();
7936 return resultobj;
7937 fail:
7938 return NULL;
7939 }
7940
7941
7942 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7943 PyObject *resultobj = 0;
7944 wxMouseState *arg1 = (wxMouseState *) 0 ;
7945 bool arg2 ;
7946 void *argp1 = 0 ;
7947 int res1 = 0 ;
7948 bool val2 ;
7949 int ecode2 = 0 ;
7950 PyObject * obj0 = 0 ;
7951 PyObject * obj1 = 0 ;
7952 char * kwnames[] = {
7953 (char *) "self",(char *) "down", NULL
7954 };
7955
7956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7958 if (!SWIG_IsOK(res1)) {
7959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7960 }
7961 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7962 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7963 if (!SWIG_IsOK(ecode2)) {
7964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7965 }
7966 arg2 = static_cast< bool >(val2);
7967 {
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 (arg1)->SetAltDown(arg2);
7970 wxPyEndAllowThreads(__tstate);
7971 if (PyErr_Occurred()) SWIG_fail;
7972 }
7973 resultobj = SWIG_Py_Void();
7974 return resultobj;
7975 fail:
7976 return NULL;
7977 }
7978
7979
7980 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7981 PyObject *resultobj = 0;
7982 wxMouseState *arg1 = (wxMouseState *) 0 ;
7983 bool arg2 ;
7984 void *argp1 = 0 ;
7985 int res1 = 0 ;
7986 bool val2 ;
7987 int ecode2 = 0 ;
7988 PyObject * obj0 = 0 ;
7989 PyObject * obj1 = 0 ;
7990 char * kwnames[] = {
7991 (char *) "self",(char *) "down", NULL
7992 };
7993
7994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7996 if (!SWIG_IsOK(res1)) {
7997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7998 }
7999 arg1 = reinterpret_cast< wxMouseState * >(argp1);
8000 ecode2 = SWIG_AsVal_bool(obj1, &val2);
8001 if (!SWIG_IsOK(ecode2)) {
8002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
8003 }
8004 arg2 = static_cast< bool >(val2);
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 (arg1)->SetMetaDown(arg2);
8008 wxPyEndAllowThreads(__tstate);
8009 if (PyErr_Occurred()) SWIG_fail;
8010 }
8011 resultobj = SWIG_Py_Void();
8012 return resultobj;
8013 fail:
8014 return NULL;
8015 }
8016
8017
8018 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8019 PyObject *obj;
8020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8021 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
8022 return SWIG_Py_Void();
8023 }
8024
8025 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8026 return SWIG_Python_InitShadowInstance(args);
8027 }
8028
8029 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8030 PyObject *resultobj = 0;
8031 wxMouseState result;
8032
8033 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
8034 {
8035 PyThreadState* __tstate = wxPyBeginAllowThreads();
8036 result = wxGetMouseState();
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
8041 return resultobj;
8042 fail:
8043 return NULL;
8044 }
8045
8046
8047 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8048 PyObject *resultobj = 0;
8049
8050 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
8051 {
8052 if (!wxPyCheckForApp()) SWIG_fail;
8053 PyThreadState* __tstate = wxPyBeginAllowThreads();
8054 wxWakeUpMainThread();
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 resultobj = SWIG_Py_Void();
8059 return resultobj;
8060 fail:
8061 return NULL;
8062 }
8063
8064
8065 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8066 PyObject *resultobj = 0;
8067
8068 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
8069 {
8070 if (!wxPyCheckForApp()) SWIG_fail;
8071 PyThreadState* __tstate = wxPyBeginAllowThreads();
8072 wxMutexGuiEnter();
8073 wxPyEndAllowThreads(__tstate);
8074 if (PyErr_Occurred()) SWIG_fail;
8075 }
8076 resultobj = SWIG_Py_Void();
8077 return resultobj;
8078 fail:
8079 return NULL;
8080 }
8081
8082
8083 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8084 PyObject *resultobj = 0;
8085
8086 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8087 {
8088 if (!wxPyCheckForApp()) SWIG_fail;
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 wxMutexGuiLeave();
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 resultobj = SWIG_Py_Void();
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8102 PyObject *resultobj = 0;
8103 wxMutexGuiLocker *result = 0 ;
8104
8105 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8106 {
8107 if (!wxPyCheckForApp()) SWIG_fail;
8108 PyThreadState* __tstate = wxPyBeginAllowThreads();
8109 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8110 wxPyEndAllowThreads(__tstate);
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8121 PyObject *resultobj = 0;
8122 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8123 void *argp1 = 0 ;
8124 int res1 = 0 ;
8125 PyObject *swig_obj[1] ;
8126
8127 if (!args) SWIG_fail;
8128 swig_obj[0] = args;
8129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8130 if (!SWIG_IsOK(res1)) {
8131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8132 }
8133 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 delete arg1;
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_Py_Void();
8142 return resultobj;
8143 fail:
8144 return NULL;
8145 }
8146
8147
8148 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8149 PyObject *obj;
8150 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8151 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8152 return SWIG_Py_Void();
8153 }
8154
8155 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8156 return SWIG_Python_InitShadowInstance(args);
8157 }
8158
8159 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160 PyObject *resultobj = 0;
8161 bool result;
8162
8163 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8164 {
8165 PyThreadState* __tstate = wxPyBeginAllowThreads();
8166 result = (bool)wxThread_IsMain();
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 {
8171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8172 }
8173 return resultobj;
8174 fail:
8175 return NULL;
8176 }
8177
8178
8179 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8180 PyObject *resultobj = 0;
8181 wxString *arg1 = 0 ;
8182 wxToolTip *result = 0 ;
8183 bool temp1 = false ;
8184 PyObject * obj0 = 0 ;
8185 char * kwnames[] = {
8186 (char *) "tip", NULL
8187 };
8188
8189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8190 {
8191 arg1 = wxString_in_helper(obj0);
8192 if (arg1 == NULL) SWIG_fail;
8193 temp1 = true;
8194 }
8195 {
8196 if (!wxPyCheckForApp()) SWIG_fail;
8197 PyThreadState* __tstate = wxPyBeginAllowThreads();
8198 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8199 wxPyEndAllowThreads(__tstate);
8200 if (PyErr_Occurred()) SWIG_fail;
8201 }
8202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8203 {
8204 if (temp1)
8205 delete arg1;
8206 }
8207 return resultobj;
8208 fail:
8209 {
8210 if (temp1)
8211 delete arg1;
8212 }
8213 return NULL;
8214 }
8215
8216
8217 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8218 PyObject *resultobj = 0;
8219 wxToolTip *arg1 = (wxToolTip *) 0 ;
8220 void *argp1 = 0 ;
8221 int res1 = 0 ;
8222 PyObject *swig_obj[1] ;
8223
8224 if (!args) SWIG_fail;
8225 swig_obj[0] = args;
8226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8227 if (!SWIG_IsOK(res1)) {
8228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8229 }
8230 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 delete arg1;
8234
8235 wxPyEndAllowThreads(__tstate);
8236 if (PyErr_Occurred()) SWIG_fail;
8237 }
8238 resultobj = SWIG_Py_Void();
8239 return resultobj;
8240 fail:
8241 return NULL;
8242 }
8243
8244
8245 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8246 PyObject *resultobj = 0;
8247 wxToolTip *arg1 = (wxToolTip *) 0 ;
8248 wxString *arg2 = 0 ;
8249 void *argp1 = 0 ;
8250 int res1 = 0 ;
8251 bool temp2 = false ;
8252 PyObject * obj0 = 0 ;
8253 PyObject * obj1 = 0 ;
8254 char * kwnames[] = {
8255 (char *) "self",(char *) "tip", NULL
8256 };
8257
8258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8260 if (!SWIG_IsOK(res1)) {
8261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8262 }
8263 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8264 {
8265 arg2 = wxString_in_helper(obj1);
8266 if (arg2 == NULL) SWIG_fail;
8267 temp2 = true;
8268 }
8269 {
8270 PyThreadState* __tstate = wxPyBeginAllowThreads();
8271 (arg1)->SetTip((wxString const &)*arg2);
8272 wxPyEndAllowThreads(__tstate);
8273 if (PyErr_Occurred()) SWIG_fail;
8274 }
8275 resultobj = SWIG_Py_Void();
8276 {
8277 if (temp2)
8278 delete arg2;
8279 }
8280 return resultobj;
8281 fail:
8282 {
8283 if (temp2)
8284 delete arg2;
8285 }
8286 return NULL;
8287 }
8288
8289
8290 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8291 PyObject *resultobj = 0;
8292 wxToolTip *arg1 = (wxToolTip *) 0 ;
8293 wxString result;
8294 void *argp1 = 0 ;
8295 int res1 = 0 ;
8296 PyObject *swig_obj[1] ;
8297
8298 if (!args) SWIG_fail;
8299 swig_obj[0] = args;
8300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8301 if (!SWIG_IsOK(res1)) {
8302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8303 }
8304 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8305 {
8306 PyThreadState* __tstate = wxPyBeginAllowThreads();
8307 result = (arg1)->GetTip();
8308 wxPyEndAllowThreads(__tstate);
8309 if (PyErr_Occurred()) SWIG_fail;
8310 }
8311 {
8312 #if wxUSE_UNICODE
8313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8314 #else
8315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8316 #endif
8317 }
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8325 PyObject *resultobj = 0;
8326 wxToolTip *arg1 = (wxToolTip *) 0 ;
8327 wxWindow *result = 0 ;
8328 void *argp1 = 0 ;
8329 int res1 = 0 ;
8330 PyObject *swig_obj[1] ;
8331
8332 if (!args) SWIG_fail;
8333 swig_obj[0] = args;
8334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8335 if (!SWIG_IsOK(res1)) {
8336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8337 }
8338 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = (wxWindow *)(arg1)->GetWindow();
8342 wxPyEndAllowThreads(__tstate);
8343 if (PyErr_Occurred()) SWIG_fail;
8344 }
8345 {
8346 resultobj = wxPyMake_wxObject(result, 0);
8347 }
8348 return resultobj;
8349 fail:
8350 return NULL;
8351 }
8352
8353
8354 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8355 PyObject *resultobj = 0;
8356 bool arg1 ;
8357 bool val1 ;
8358 int ecode1 = 0 ;
8359 PyObject * obj0 = 0 ;
8360 char * kwnames[] = {
8361 (char *) "flag", NULL
8362 };
8363
8364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8365 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8366 if (!SWIG_IsOK(ecode1)) {
8367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8368 }
8369 arg1 = static_cast< bool >(val1);
8370 {
8371 PyThreadState* __tstate = wxPyBeginAllowThreads();
8372 wxToolTip::Enable(arg1);
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 resultobj = SWIG_Py_Void();
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8384 PyObject *resultobj = 0;
8385 long arg1 ;
8386 long val1 ;
8387 int ecode1 = 0 ;
8388 PyObject * obj0 = 0 ;
8389 char * kwnames[] = {
8390 (char *) "milliseconds", NULL
8391 };
8392
8393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8394 ecode1 = SWIG_AsVal_long(obj0, &val1);
8395 if (!SWIG_IsOK(ecode1)) {
8396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8397 }
8398 arg1 = static_cast< long >(val1);
8399 {
8400 PyThreadState* __tstate = wxPyBeginAllowThreads();
8401 wxToolTip::SetDelay(arg1);
8402 wxPyEndAllowThreads(__tstate);
8403 if (PyErr_Occurred()) SWIG_fail;
8404 }
8405 resultobj = SWIG_Py_Void();
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8413 PyObject *obj;
8414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8415 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8416 return SWIG_Py_Void();
8417 }
8418
8419 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8420 return SWIG_Python_InitShadowInstance(args);
8421 }
8422
8423 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8424 PyObject *resultobj = 0;
8425 wxWindow *arg1 = (wxWindow *) 0 ;
8426 wxSize *arg2 = 0 ;
8427 wxCaret *result = 0 ;
8428 void *argp1 = 0 ;
8429 int res1 = 0 ;
8430 wxSize temp2 ;
8431 PyObject * obj0 = 0 ;
8432 PyObject * obj1 = 0 ;
8433 char * kwnames[] = {
8434 (char *) "window",(char *) "size", NULL
8435 };
8436
8437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8439 if (!SWIG_IsOK(res1)) {
8440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8441 }
8442 arg1 = reinterpret_cast< wxWindow * >(argp1);
8443 {
8444 arg2 = &temp2;
8445 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8446 }
8447 {
8448 if (!wxPyCheckForApp()) SWIG_fail;
8449 PyThreadState* __tstate = wxPyBeginAllowThreads();
8450 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8451 wxPyEndAllowThreads(__tstate);
8452 if (PyErr_Occurred()) SWIG_fail;
8453 }
8454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8455 return resultobj;
8456 fail:
8457 return NULL;
8458 }
8459
8460
8461 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8462 PyObject *resultobj = 0;
8463 wxCaret *arg1 = (wxCaret *) 0 ;
8464 void *argp1 = 0 ;
8465 int res1 = 0 ;
8466 PyObject *swig_obj[1] ;
8467
8468 if (!args) SWIG_fail;
8469 swig_obj[0] = args;
8470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8471 if (!SWIG_IsOK(res1)) {
8472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8473 }
8474 arg1 = reinterpret_cast< wxCaret * >(argp1);
8475 {
8476 PyThreadState* __tstate = wxPyBeginAllowThreads();
8477 delete arg1;
8478
8479 wxPyEndAllowThreads(__tstate);
8480 if (PyErr_Occurred()) SWIG_fail;
8481 }
8482 resultobj = SWIG_Py_Void();
8483 return resultobj;
8484 fail:
8485 return NULL;
8486 }
8487
8488
8489 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8490 PyObject *resultobj = 0;
8491 wxCaret *arg1 = (wxCaret *) 0 ;
8492 void *argp1 = 0 ;
8493 int res1 = 0 ;
8494 PyObject *swig_obj[1] ;
8495
8496 if (!args) SWIG_fail;
8497 swig_obj[0] = args;
8498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8501 }
8502 arg1 = reinterpret_cast< wxCaret * >(argp1);
8503 {
8504 PyThreadState* __tstate = wxPyBeginAllowThreads();
8505 wxCaret_Destroy(arg1);
8506 wxPyEndAllowThreads(__tstate);
8507 if (PyErr_Occurred()) SWIG_fail;
8508 }
8509 resultobj = SWIG_Py_Void();
8510 return resultobj;
8511 fail:
8512 return NULL;
8513 }
8514
8515
8516 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8517 PyObject *resultobj = 0;
8518 wxCaret *arg1 = (wxCaret *) 0 ;
8519 bool result;
8520 void *argp1 = 0 ;
8521 int res1 = 0 ;
8522 PyObject *swig_obj[1] ;
8523
8524 if (!args) SWIG_fail;
8525 swig_obj[0] = args;
8526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8527 if (!SWIG_IsOK(res1)) {
8528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8529 }
8530 arg1 = reinterpret_cast< wxCaret * >(argp1);
8531 {
8532 PyThreadState* __tstate = wxPyBeginAllowThreads();
8533 result = (bool)(arg1)->IsOk();
8534 wxPyEndAllowThreads(__tstate);
8535 if (PyErr_Occurred()) SWIG_fail;
8536 }
8537 {
8538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8539 }
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxCaret *arg1 = (wxCaret *) 0 ;
8549 bool result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8559 }
8560 arg1 = reinterpret_cast< wxCaret * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (bool)(arg1)->IsVisible();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 {
8568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8569 }
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8577 PyObject *resultobj = 0;
8578 wxCaret *arg1 = (wxCaret *) 0 ;
8579 wxPoint result;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 PyObject *swig_obj[1] ;
8583
8584 if (!args) SWIG_fail;
8585 swig_obj[0] = args;
8586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8587 if (!SWIG_IsOK(res1)) {
8588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8589 }
8590 arg1 = reinterpret_cast< wxCaret * >(argp1);
8591 {
8592 PyThreadState* __tstate = wxPyBeginAllowThreads();
8593 result = (arg1)->GetPosition();
8594 wxPyEndAllowThreads(__tstate);
8595 if (PyErr_Occurred()) SWIG_fail;
8596 }
8597 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8598 return resultobj;
8599 fail:
8600 return NULL;
8601 }
8602
8603
8604 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8605 PyObject *resultobj = 0;
8606 wxCaret *arg1 = (wxCaret *) 0 ;
8607 int *arg2 = (int *) 0 ;
8608 int *arg3 = (int *) 0 ;
8609 void *argp1 = 0 ;
8610 int res1 = 0 ;
8611 int temp2 ;
8612 int res2 = SWIG_TMPOBJ ;
8613 int temp3 ;
8614 int res3 = SWIG_TMPOBJ ;
8615 PyObject *swig_obj[1] ;
8616
8617 arg2 = &temp2;
8618 arg3 = &temp3;
8619 if (!args) SWIG_fail;
8620 swig_obj[0] = args;
8621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8622 if (!SWIG_IsOK(res1)) {
8623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8624 }
8625 arg1 = reinterpret_cast< wxCaret * >(argp1);
8626 {
8627 PyThreadState* __tstate = wxPyBeginAllowThreads();
8628 (arg1)->GetPosition(arg2,arg3);
8629 wxPyEndAllowThreads(__tstate);
8630 if (PyErr_Occurred()) SWIG_fail;
8631 }
8632 resultobj = SWIG_Py_Void();
8633 if (SWIG_IsTmpObj(res2)) {
8634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8635 } else {
8636 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8637 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8638 }
8639 if (SWIG_IsTmpObj(res3)) {
8640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8641 } else {
8642 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8644 }
8645 return resultobj;
8646 fail:
8647 return NULL;
8648 }
8649
8650
8651 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8652 PyObject *resultobj = 0;
8653 wxCaret *arg1 = (wxCaret *) 0 ;
8654 wxSize result;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 PyObject *swig_obj[1] ;
8658
8659 if (!args) SWIG_fail;
8660 swig_obj[0] = args;
8661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8662 if (!SWIG_IsOK(res1)) {
8663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8664 }
8665 arg1 = reinterpret_cast< wxCaret * >(argp1);
8666 {
8667 PyThreadState* __tstate = wxPyBeginAllowThreads();
8668 result = (arg1)->GetSize();
8669 wxPyEndAllowThreads(__tstate);
8670 if (PyErr_Occurred()) SWIG_fail;
8671 }
8672 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8673 return resultobj;
8674 fail:
8675 return NULL;
8676 }
8677
8678
8679 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8680 PyObject *resultobj = 0;
8681 wxCaret *arg1 = (wxCaret *) 0 ;
8682 int *arg2 = (int *) 0 ;
8683 int *arg3 = (int *) 0 ;
8684 void *argp1 = 0 ;
8685 int res1 = 0 ;
8686 int temp2 ;
8687 int res2 = SWIG_TMPOBJ ;
8688 int temp3 ;
8689 int res3 = SWIG_TMPOBJ ;
8690 PyObject *swig_obj[1] ;
8691
8692 arg2 = &temp2;
8693 arg3 = &temp3;
8694 if (!args) SWIG_fail;
8695 swig_obj[0] = args;
8696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8697 if (!SWIG_IsOK(res1)) {
8698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8699 }
8700 arg1 = reinterpret_cast< wxCaret * >(argp1);
8701 {
8702 PyThreadState* __tstate = wxPyBeginAllowThreads();
8703 (arg1)->GetSize(arg2,arg3);
8704 wxPyEndAllowThreads(__tstate);
8705 if (PyErr_Occurred()) SWIG_fail;
8706 }
8707 resultobj = SWIG_Py_Void();
8708 if (SWIG_IsTmpObj(res2)) {
8709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8710 } else {
8711 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8713 }
8714 if (SWIG_IsTmpObj(res3)) {
8715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8716 } else {
8717 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8719 }
8720 return resultobj;
8721 fail:
8722 return NULL;
8723 }
8724
8725
8726 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8727 PyObject *resultobj = 0;
8728 wxCaret *arg1 = (wxCaret *) 0 ;
8729 wxWindow *result = 0 ;
8730 void *argp1 = 0 ;
8731 int res1 = 0 ;
8732 PyObject *swig_obj[1] ;
8733
8734 if (!args) SWIG_fail;
8735 swig_obj[0] = args;
8736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8737 if (!SWIG_IsOK(res1)) {
8738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8739 }
8740 arg1 = reinterpret_cast< wxCaret * >(argp1);
8741 {
8742 PyThreadState* __tstate = wxPyBeginAllowThreads();
8743 result = (wxWindow *)(arg1)->GetWindow();
8744 wxPyEndAllowThreads(__tstate);
8745 if (PyErr_Occurred()) SWIG_fail;
8746 }
8747 {
8748 resultobj = wxPyMake_wxObject(result, 0);
8749 }
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8757 PyObject *resultobj = 0;
8758 wxCaret *arg1 = (wxCaret *) 0 ;
8759 int arg2 ;
8760 int arg3 ;
8761 void *argp1 = 0 ;
8762 int res1 = 0 ;
8763 int val2 ;
8764 int ecode2 = 0 ;
8765 int val3 ;
8766 int ecode3 = 0 ;
8767 PyObject * obj0 = 0 ;
8768 PyObject * obj1 = 0 ;
8769 PyObject * obj2 = 0 ;
8770 char * kwnames[] = {
8771 (char *) "self",(char *) "x",(char *) "y", NULL
8772 };
8773
8774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8778 }
8779 arg1 = reinterpret_cast< wxCaret * >(argp1);
8780 ecode2 = SWIG_AsVal_int(obj1, &val2);
8781 if (!SWIG_IsOK(ecode2)) {
8782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8783 }
8784 arg2 = static_cast< int >(val2);
8785 ecode3 = SWIG_AsVal_int(obj2, &val3);
8786 if (!SWIG_IsOK(ecode3)) {
8787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8788 }
8789 arg3 = static_cast< int >(val3);
8790 {
8791 PyThreadState* __tstate = wxPyBeginAllowThreads();
8792 (arg1)->Move(arg2,arg3);
8793 wxPyEndAllowThreads(__tstate);
8794 if (PyErr_Occurred()) SWIG_fail;
8795 }
8796 resultobj = SWIG_Py_Void();
8797 return resultobj;
8798 fail:
8799 return NULL;
8800 }
8801
8802
8803 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8804 PyObject *resultobj = 0;
8805 wxCaret *arg1 = (wxCaret *) 0 ;
8806 wxPoint *arg2 = 0 ;
8807 void *argp1 = 0 ;
8808 int res1 = 0 ;
8809 wxPoint temp2 ;
8810 PyObject * obj0 = 0 ;
8811 PyObject * obj1 = 0 ;
8812 char * kwnames[] = {
8813 (char *) "self",(char *) "pt", NULL
8814 };
8815
8816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8818 if (!SWIG_IsOK(res1)) {
8819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8820 }
8821 arg1 = reinterpret_cast< wxCaret * >(argp1);
8822 {
8823 arg2 = &temp2;
8824 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8825 }
8826 {
8827 PyThreadState* __tstate = wxPyBeginAllowThreads();
8828 (arg1)->Move((wxPoint const &)*arg2);
8829 wxPyEndAllowThreads(__tstate);
8830 if (PyErr_Occurred()) SWIG_fail;
8831 }
8832 resultobj = SWIG_Py_Void();
8833 return resultobj;
8834 fail:
8835 return NULL;
8836 }
8837
8838
8839 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8840 PyObject *resultobj = 0;
8841 wxCaret *arg1 = (wxCaret *) 0 ;
8842 int arg2 ;
8843 int arg3 ;
8844 void *argp1 = 0 ;
8845 int res1 = 0 ;
8846 int val2 ;
8847 int ecode2 = 0 ;
8848 int val3 ;
8849 int ecode3 = 0 ;
8850 PyObject * obj0 = 0 ;
8851 PyObject * obj1 = 0 ;
8852 PyObject * obj2 = 0 ;
8853 char * kwnames[] = {
8854 (char *) "self",(char *) "width",(char *) "height", NULL
8855 };
8856
8857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8859 if (!SWIG_IsOK(res1)) {
8860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8861 }
8862 arg1 = reinterpret_cast< wxCaret * >(argp1);
8863 ecode2 = SWIG_AsVal_int(obj1, &val2);
8864 if (!SWIG_IsOK(ecode2)) {
8865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8866 }
8867 arg2 = static_cast< int >(val2);
8868 ecode3 = SWIG_AsVal_int(obj2, &val3);
8869 if (!SWIG_IsOK(ecode3)) {
8870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8871 }
8872 arg3 = static_cast< int >(val3);
8873 {
8874 PyThreadState* __tstate = wxPyBeginAllowThreads();
8875 (arg1)->SetSize(arg2,arg3);
8876 wxPyEndAllowThreads(__tstate);
8877 if (PyErr_Occurred()) SWIG_fail;
8878 }
8879 resultobj = SWIG_Py_Void();
8880 return resultobj;
8881 fail:
8882 return NULL;
8883 }
8884
8885
8886 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8887 PyObject *resultobj = 0;
8888 wxCaret *arg1 = (wxCaret *) 0 ;
8889 wxSize *arg2 = 0 ;
8890 void *argp1 = 0 ;
8891 int res1 = 0 ;
8892 wxSize temp2 ;
8893 PyObject * obj0 = 0 ;
8894 PyObject * obj1 = 0 ;
8895 char * kwnames[] = {
8896 (char *) "self",(char *) "size", NULL
8897 };
8898
8899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8901 if (!SWIG_IsOK(res1)) {
8902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8903 }
8904 arg1 = reinterpret_cast< wxCaret * >(argp1);
8905 {
8906 arg2 = &temp2;
8907 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8908 }
8909 {
8910 PyThreadState* __tstate = wxPyBeginAllowThreads();
8911 (arg1)->SetSize((wxSize const &)*arg2);
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 resultobj = SWIG_Py_Void();
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8923 PyObject *resultobj = 0;
8924 wxCaret *arg1 = (wxCaret *) 0 ;
8925 int arg2 = (int) true ;
8926 void *argp1 = 0 ;
8927 int res1 = 0 ;
8928 int val2 ;
8929 int ecode2 = 0 ;
8930 PyObject * obj0 = 0 ;
8931 PyObject * obj1 = 0 ;
8932 char * kwnames[] = {
8933 (char *) "self",(char *) "show", NULL
8934 };
8935
8936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8938 if (!SWIG_IsOK(res1)) {
8939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8940 }
8941 arg1 = reinterpret_cast< wxCaret * >(argp1);
8942 if (obj1) {
8943 ecode2 = SWIG_AsVal_int(obj1, &val2);
8944 if (!SWIG_IsOK(ecode2)) {
8945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8946 }
8947 arg2 = static_cast< int >(val2);
8948 }
8949 {
8950 PyThreadState* __tstate = wxPyBeginAllowThreads();
8951 (arg1)->Show(arg2);
8952 wxPyEndAllowThreads(__tstate);
8953 if (PyErr_Occurred()) SWIG_fail;
8954 }
8955 resultobj = SWIG_Py_Void();
8956 return resultobj;
8957 fail:
8958 return NULL;
8959 }
8960
8961
8962 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8963 PyObject *resultobj = 0;
8964 wxCaret *arg1 = (wxCaret *) 0 ;
8965 void *argp1 = 0 ;
8966 int res1 = 0 ;
8967 PyObject *swig_obj[1] ;
8968
8969 if (!args) SWIG_fail;
8970 swig_obj[0] = args;
8971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8972 if (!SWIG_IsOK(res1)) {
8973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8974 }
8975 arg1 = reinterpret_cast< wxCaret * >(argp1);
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 (arg1)->Hide();
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 resultobj = SWIG_Py_Void();
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8990 PyObject *resultobj = 0;
8991 int result;
8992
8993 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8994 {
8995 PyThreadState* __tstate = wxPyBeginAllowThreads();
8996 result = (int)wxCaret::GetBlinkTime();
8997 wxPyEndAllowThreads(__tstate);
8998 if (PyErr_Occurred()) SWIG_fail;
8999 }
9000 resultobj = SWIG_From_int(static_cast< int >(result));
9001 return resultobj;
9002 fail:
9003 return NULL;
9004 }
9005
9006
9007 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9008 PyObject *resultobj = 0;
9009 int arg1 ;
9010 int val1 ;
9011 int ecode1 = 0 ;
9012 PyObject * obj0 = 0 ;
9013 char * kwnames[] = {
9014 (char *) "milliseconds", NULL
9015 };
9016
9017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
9018 ecode1 = SWIG_AsVal_int(obj0, &val1);
9019 if (!SWIG_IsOK(ecode1)) {
9020 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
9021 }
9022 arg1 = static_cast< int >(val1);
9023 {
9024 PyThreadState* __tstate = wxPyBeginAllowThreads();
9025 wxCaret::SetBlinkTime(arg1);
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 resultobj = SWIG_Py_Void();
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9037 PyObject *obj;
9038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9039 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
9040 return SWIG_Py_Void();
9041 }
9042
9043 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9044 return SWIG_Python_InitShadowInstance(args);
9045 }
9046
9047 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9048 PyObject *resultobj = 0;
9049 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
9050 wxBusyCursor *result = 0 ;
9051 void *argp1 = 0 ;
9052 int res1 = 0 ;
9053 PyObject * obj0 = 0 ;
9054 char * kwnames[] = {
9055 (char *) "cursor", NULL
9056 };
9057
9058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
9059 if (obj0) {
9060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
9061 if (!SWIG_IsOK(res1)) {
9062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
9063 }
9064 arg1 = reinterpret_cast< wxCursor * >(argp1);
9065 }
9066 {
9067 if (!wxPyCheckForApp()) SWIG_fail;
9068 PyThreadState* __tstate = wxPyBeginAllowThreads();
9069 result = (wxBusyCursor *)new wxBusyCursor(arg1);
9070 wxPyEndAllowThreads(__tstate);
9071 if (PyErr_Occurred()) SWIG_fail;
9072 }
9073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
9074 return resultobj;
9075 fail:
9076 return NULL;
9077 }
9078
9079
9080 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9081 PyObject *resultobj = 0;
9082 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
9083 void *argp1 = 0 ;
9084 int res1 = 0 ;
9085 PyObject *swig_obj[1] ;
9086
9087 if (!args) SWIG_fail;
9088 swig_obj[0] = args;
9089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9090 if (!SWIG_IsOK(res1)) {
9091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9092 }
9093 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9094 {
9095 PyThreadState* __tstate = wxPyBeginAllowThreads();
9096 delete arg1;
9097
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 resultobj = SWIG_Py_Void();
9102 return resultobj;
9103 fail:
9104 return NULL;
9105 }
9106
9107
9108 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9109 PyObject *obj;
9110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9111 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9112 return SWIG_Py_Void();
9113 }
9114
9115 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9116 return SWIG_Python_InitShadowInstance(args);
9117 }
9118
9119 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj = 0;
9121 wxWindow *arg1 = (wxWindow *) NULL ;
9122 wxWindowDisabler *result = 0 ;
9123 void *argp1 = 0 ;
9124 int res1 = 0 ;
9125 PyObject * obj0 = 0 ;
9126 char * kwnames[] = {
9127 (char *) "winToSkip", NULL
9128 };
9129
9130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9131 if (obj0) {
9132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9133 if (!SWIG_IsOK(res1)) {
9134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9135 }
9136 arg1 = reinterpret_cast< wxWindow * >(argp1);
9137 }
9138 {
9139 if (!wxPyCheckForApp()) SWIG_fail;
9140 PyThreadState* __tstate = wxPyBeginAllowThreads();
9141 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9142 wxPyEndAllowThreads(__tstate);
9143 if (PyErr_Occurred()) SWIG_fail;
9144 }
9145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9146 return resultobj;
9147 fail:
9148 return NULL;
9149 }
9150
9151
9152 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9153 PyObject *resultobj = 0;
9154 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9155 void *argp1 = 0 ;
9156 int res1 = 0 ;
9157 PyObject *swig_obj[1] ;
9158
9159 if (!args) SWIG_fail;
9160 swig_obj[0] = args;
9161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9162 if (!SWIG_IsOK(res1)) {
9163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9164 }
9165 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9166 {
9167 PyThreadState* __tstate = wxPyBeginAllowThreads();
9168 delete arg1;
9169
9170 wxPyEndAllowThreads(__tstate);
9171 if (PyErr_Occurred()) SWIG_fail;
9172 }
9173 resultobj = SWIG_Py_Void();
9174 return resultobj;
9175 fail:
9176 return NULL;
9177 }
9178
9179
9180 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9181 PyObject *obj;
9182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9183 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9184 return SWIG_Py_Void();
9185 }
9186
9187 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9188 return SWIG_Python_InitShadowInstance(args);
9189 }
9190
9191 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9192 PyObject *resultobj = 0;
9193 wxString *arg1 = 0 ;
9194 wxBusyInfo *result = 0 ;
9195 bool temp1 = false ;
9196 PyObject * obj0 = 0 ;
9197 char * kwnames[] = {
9198 (char *) "message", NULL
9199 };
9200
9201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9202 {
9203 arg1 = wxString_in_helper(obj0);
9204 if (arg1 == NULL) SWIG_fail;
9205 temp1 = true;
9206 }
9207 {
9208 if (!wxPyCheckForApp()) SWIG_fail;
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9215 {
9216 if (temp1)
9217 delete arg1;
9218 }
9219 return resultobj;
9220 fail:
9221 {
9222 if (temp1)
9223 delete arg1;
9224 }
9225 return NULL;
9226 }
9227
9228
9229 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9230 PyObject *resultobj = 0;
9231 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9232 void *argp1 = 0 ;
9233 int res1 = 0 ;
9234 PyObject *swig_obj[1] ;
9235
9236 if (!args) SWIG_fail;
9237 swig_obj[0] = args;
9238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9239 if (!SWIG_IsOK(res1)) {
9240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9241 }
9242 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9243 {
9244 PyThreadState* __tstate = wxPyBeginAllowThreads();
9245 delete arg1;
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 resultobj = SWIG_Py_Void();
9251 return resultobj;
9252 fail:
9253 return NULL;
9254 }
9255
9256
9257 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9258 PyObject *obj;
9259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9260 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9261 return SWIG_Py_Void();
9262 }
9263
9264 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9265 return SWIG_Python_InitShadowInstance(args);
9266 }
9267
9268 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9269 PyObject *resultobj = 0;
9270 wxStopWatch *result = 0 ;
9271
9272 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9273 {
9274 PyThreadState* __tstate = wxPyBeginAllowThreads();
9275 result = (wxStopWatch *)new wxStopWatch();
9276 wxPyEndAllowThreads(__tstate);
9277 if (PyErr_Occurred()) SWIG_fail;
9278 }
9279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9280 return resultobj;
9281 fail:
9282 return NULL;
9283 }
9284
9285
9286 SWIGINTERN PyObject *_wrap_delete_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9287 PyObject *resultobj = 0;
9288 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9289 void *argp1 = 0 ;
9290 int res1 = 0 ;
9291 PyObject *swig_obj[1] ;
9292
9293 if (!args) SWIG_fail;
9294 swig_obj[0] = args;
9295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, SWIG_POINTER_DISOWN | 0 );
9296 if (!SWIG_IsOK(res1)) {
9297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StopWatch" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9298 }
9299 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 delete arg1;
9303
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 resultobj = SWIG_Py_Void();
9308 return resultobj;
9309 fail:
9310 return NULL;
9311 }
9312
9313
9314 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9315 PyObject *resultobj = 0;
9316 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9317 long arg2 = (long) 0 ;
9318 void *argp1 = 0 ;
9319 int res1 = 0 ;
9320 long val2 ;
9321 int ecode2 = 0 ;
9322 PyObject * obj0 = 0 ;
9323 PyObject * obj1 = 0 ;
9324 char * kwnames[] = {
9325 (char *) "self",(char *) "t0", NULL
9326 };
9327
9328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9330 if (!SWIG_IsOK(res1)) {
9331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9332 }
9333 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9334 if (obj1) {
9335 ecode2 = SWIG_AsVal_long(obj1, &val2);
9336 if (!SWIG_IsOK(ecode2)) {
9337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9338 }
9339 arg2 = static_cast< long >(val2);
9340 }
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 (arg1)->Start(arg2);
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 resultobj = SWIG_Py_Void();
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9355 PyObject *resultobj = 0;
9356 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9357 void *argp1 = 0 ;
9358 int res1 = 0 ;
9359 PyObject *swig_obj[1] ;
9360
9361 if (!args) SWIG_fail;
9362 swig_obj[0] = args;
9363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9364 if (!SWIG_IsOK(res1)) {
9365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9366 }
9367 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9368 {
9369 PyThreadState* __tstate = wxPyBeginAllowThreads();
9370 (arg1)->Pause();
9371 wxPyEndAllowThreads(__tstate);
9372 if (PyErr_Occurred()) SWIG_fail;
9373 }
9374 resultobj = SWIG_Py_Void();
9375 return resultobj;
9376 fail:
9377 return NULL;
9378 }
9379
9380
9381 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9382 PyObject *resultobj = 0;
9383 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9384 void *argp1 = 0 ;
9385 int res1 = 0 ;
9386 PyObject *swig_obj[1] ;
9387
9388 if (!args) SWIG_fail;
9389 swig_obj[0] = args;
9390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9391 if (!SWIG_IsOK(res1)) {
9392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9393 }
9394 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9395 {
9396 PyThreadState* __tstate = wxPyBeginAllowThreads();
9397 (arg1)->Resume();
9398 wxPyEndAllowThreads(__tstate);
9399 if (PyErr_Occurred()) SWIG_fail;
9400 }
9401 resultobj = SWIG_Py_Void();
9402 return resultobj;
9403 fail:
9404 return NULL;
9405 }
9406
9407
9408 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9409 PyObject *resultobj = 0;
9410 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9411 long result;
9412 void *argp1 = 0 ;
9413 int res1 = 0 ;
9414 PyObject *swig_obj[1] ;
9415
9416 if (!args) SWIG_fail;
9417 swig_obj[0] = args;
9418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9419 if (!SWIG_IsOK(res1)) {
9420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9421 }
9422 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9423 {
9424 PyThreadState* __tstate = wxPyBeginAllowThreads();
9425 result = (long)((wxStopWatch const *)arg1)->Time();
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 resultobj = SWIG_From_long(static_cast< long >(result));
9430 return resultobj;
9431 fail:
9432 return NULL;
9433 }
9434
9435
9436 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9437 PyObject *obj;
9438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9439 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9440 return SWIG_Py_Void();
9441 }
9442
9443 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9444 return SWIG_Python_InitShadowInstance(args);
9445 }
9446
9447 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9448 PyObject *resultobj = 0;
9449 int arg1 = (int) 9 ;
9450 int arg2 = (int) wxID_FILE1 ;
9451 wxFileHistory *result = 0 ;
9452 int val1 ;
9453 int ecode1 = 0 ;
9454 int val2 ;
9455 int ecode2 = 0 ;
9456 PyObject * obj0 = 0 ;
9457 PyObject * obj1 = 0 ;
9458 char * kwnames[] = {
9459 (char *) "maxFiles",(char *) "idBase", NULL
9460 };
9461
9462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9463 if (obj0) {
9464 ecode1 = SWIG_AsVal_int(obj0, &val1);
9465 if (!SWIG_IsOK(ecode1)) {
9466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9467 }
9468 arg1 = static_cast< int >(val1);
9469 }
9470 if (obj1) {
9471 ecode2 = SWIG_AsVal_int(obj1, &val2);
9472 if (!SWIG_IsOK(ecode2)) {
9473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9474 }
9475 arg2 = static_cast< int >(val2);
9476 }
9477 {
9478 PyThreadState* __tstate = wxPyBeginAllowThreads();
9479 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9480 wxPyEndAllowThreads(__tstate);
9481 if (PyErr_Occurred()) SWIG_fail;
9482 }
9483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9484 return resultobj;
9485 fail:
9486 return NULL;
9487 }
9488
9489
9490 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9491 PyObject *resultobj = 0;
9492 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 PyObject *swig_obj[1] ;
9496
9497 if (!args) SWIG_fail;
9498 swig_obj[0] = args;
9499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9500 if (!SWIG_IsOK(res1)) {
9501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9502 }
9503 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 delete arg1;
9507
9508 wxPyEndAllowThreads(__tstate);
9509 if (PyErr_Occurred()) SWIG_fail;
9510 }
9511 resultobj = SWIG_Py_Void();
9512 return resultobj;
9513 fail:
9514 return NULL;
9515 }
9516
9517
9518 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9519 PyObject *resultobj = 0;
9520 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9521 wxString *arg2 = 0 ;
9522 void *argp1 = 0 ;
9523 int res1 = 0 ;
9524 bool temp2 = false ;
9525 PyObject * obj0 = 0 ;
9526 PyObject * obj1 = 0 ;
9527 char * kwnames[] = {
9528 (char *) "self",(char *) "file", NULL
9529 };
9530
9531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9533 if (!SWIG_IsOK(res1)) {
9534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9535 }
9536 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9537 {
9538 arg2 = wxString_in_helper(obj1);
9539 if (arg2 == NULL) SWIG_fail;
9540 temp2 = true;
9541 }
9542 {
9543 PyThreadState* __tstate = wxPyBeginAllowThreads();
9544 (arg1)->AddFileToHistory((wxString const &)*arg2);
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 resultobj = SWIG_Py_Void();
9549 {
9550 if (temp2)
9551 delete arg2;
9552 }
9553 return resultobj;
9554 fail:
9555 {
9556 if (temp2)
9557 delete arg2;
9558 }
9559 return NULL;
9560 }
9561
9562
9563 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9564 PyObject *resultobj = 0;
9565 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9566 int arg2 ;
9567 void *argp1 = 0 ;
9568 int res1 = 0 ;
9569 int val2 ;
9570 int ecode2 = 0 ;
9571 PyObject * obj0 = 0 ;
9572 PyObject * obj1 = 0 ;
9573 char * kwnames[] = {
9574 (char *) "self",(char *) "i", NULL
9575 };
9576
9577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9579 if (!SWIG_IsOK(res1)) {
9580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9581 }
9582 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9583 ecode2 = SWIG_AsVal_int(obj1, &val2);
9584 if (!SWIG_IsOK(ecode2)) {
9585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9586 }
9587 arg2 = static_cast< int >(val2);
9588 {
9589 PyThreadState* __tstate = wxPyBeginAllowThreads();
9590 (arg1)->RemoveFileFromHistory(arg2);
9591 wxPyEndAllowThreads(__tstate);
9592 if (PyErr_Occurred()) SWIG_fail;
9593 }
9594 resultobj = SWIG_Py_Void();
9595 return resultobj;
9596 fail:
9597 return NULL;
9598 }
9599
9600
9601 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9602 PyObject *resultobj = 0;
9603 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9604 int result;
9605 void *argp1 = 0 ;
9606 int res1 = 0 ;
9607 PyObject *swig_obj[1] ;
9608
9609 if (!args) SWIG_fail;
9610 swig_obj[0] = args;
9611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9612 if (!SWIG_IsOK(res1)) {
9613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9614 }
9615 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9616 {
9617 PyThreadState* __tstate = wxPyBeginAllowThreads();
9618 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 resultobj = SWIG_From_int(static_cast< int >(result));
9623 return resultobj;
9624 fail:
9625 return NULL;
9626 }
9627
9628
9629 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9630 PyObject *resultobj = 0;
9631 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9632 wxMenu *arg2 = (wxMenu *) 0 ;
9633 void *argp1 = 0 ;
9634 int res1 = 0 ;
9635 void *argp2 = 0 ;
9636 int res2 = 0 ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 char * kwnames[] = {
9640 (char *) "self",(char *) "menu", NULL
9641 };
9642
9643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9645 if (!SWIG_IsOK(res1)) {
9646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9647 }
9648 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9650 if (!SWIG_IsOK(res2)) {
9651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9652 }
9653 arg2 = reinterpret_cast< wxMenu * >(argp2);
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 (arg1)->UseMenu(arg2);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_Py_Void();
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9668 PyObject *resultobj = 0;
9669 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9670 wxMenu *arg2 = (wxMenu *) 0 ;
9671 void *argp1 = 0 ;
9672 int res1 = 0 ;
9673 void *argp2 = 0 ;
9674 int res2 = 0 ;
9675 PyObject * obj0 = 0 ;
9676 PyObject * obj1 = 0 ;
9677 char * kwnames[] = {
9678 (char *) "self",(char *) "menu", NULL
9679 };
9680
9681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9683 if (!SWIG_IsOK(res1)) {
9684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9685 }
9686 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9687 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9688 if (!SWIG_IsOK(res2)) {
9689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9690 }
9691 arg2 = reinterpret_cast< wxMenu * >(argp2);
9692 {
9693 PyThreadState* __tstate = wxPyBeginAllowThreads();
9694 (arg1)->RemoveMenu(arg2);
9695 wxPyEndAllowThreads(__tstate);
9696 if (PyErr_Occurred()) SWIG_fail;
9697 }
9698 resultobj = SWIG_Py_Void();
9699 return resultobj;
9700 fail:
9701 return NULL;
9702 }
9703
9704
9705 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9706 PyObject *resultobj = 0;
9707 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9708 wxConfigBase *arg2 = 0 ;
9709 void *argp1 = 0 ;
9710 int res1 = 0 ;
9711 void *argp2 = 0 ;
9712 int res2 = 0 ;
9713 PyObject * obj0 = 0 ;
9714 PyObject * obj1 = 0 ;
9715 char * kwnames[] = {
9716 (char *) "self",(char *) "config", NULL
9717 };
9718
9719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9721 if (!SWIG_IsOK(res1)) {
9722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9723 }
9724 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9725 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9726 if (!SWIG_IsOK(res2)) {
9727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9728 }
9729 if (!argp2) {
9730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9731 }
9732 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9733 {
9734 PyThreadState* __tstate = wxPyBeginAllowThreads();
9735 (arg1)->Load(*arg2);
9736 wxPyEndAllowThreads(__tstate);
9737 if (PyErr_Occurred()) SWIG_fail;
9738 }
9739 resultobj = SWIG_Py_Void();
9740 return resultobj;
9741 fail:
9742 return NULL;
9743 }
9744
9745
9746 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9747 PyObject *resultobj = 0;
9748 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9749 wxConfigBase *arg2 = 0 ;
9750 void *argp1 = 0 ;
9751 int res1 = 0 ;
9752 void *argp2 = 0 ;
9753 int res2 = 0 ;
9754 PyObject * obj0 = 0 ;
9755 PyObject * obj1 = 0 ;
9756 char * kwnames[] = {
9757 (char *) "self",(char *) "config", NULL
9758 };
9759
9760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9762 if (!SWIG_IsOK(res1)) {
9763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9764 }
9765 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9766 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9767 if (!SWIG_IsOK(res2)) {
9768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9769 }
9770 if (!argp2) {
9771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9772 }
9773 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9774 {
9775 PyThreadState* __tstate = wxPyBeginAllowThreads();
9776 (arg1)->Save(*arg2);
9777 wxPyEndAllowThreads(__tstate);
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 resultobj = SWIG_Py_Void();
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9788 PyObject *resultobj = 0;
9789 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9790 void *argp1 = 0 ;
9791 int res1 = 0 ;
9792 PyObject *swig_obj[1] ;
9793
9794 if (!args) SWIG_fail;
9795 swig_obj[0] = args;
9796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9797 if (!SWIG_IsOK(res1)) {
9798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9799 }
9800 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9801 {
9802 PyThreadState* __tstate = wxPyBeginAllowThreads();
9803 (arg1)->AddFilesToMenu();
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 resultobj = SWIG_Py_Void();
9808 return resultobj;
9809 fail:
9810 return NULL;
9811 }
9812
9813
9814 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9815 PyObject *resultobj = 0;
9816 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9817 wxMenu *arg2 = (wxMenu *) 0 ;
9818 void *argp1 = 0 ;
9819 int res1 = 0 ;
9820 void *argp2 = 0 ;
9821 int res2 = 0 ;
9822 PyObject * obj0 = 0 ;
9823 PyObject * obj1 = 0 ;
9824 char * kwnames[] = {
9825 (char *) "self",(char *) "menu", NULL
9826 };
9827
9828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9830 if (!SWIG_IsOK(res1)) {
9831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9832 }
9833 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9835 if (!SWIG_IsOK(res2)) {
9836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9837 }
9838 arg2 = reinterpret_cast< wxMenu * >(argp2);
9839 {
9840 PyThreadState* __tstate = wxPyBeginAllowThreads();
9841 (arg1)->AddFilesToMenu(arg2);
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 resultobj = SWIG_Py_Void();
9846 return resultobj;
9847 fail:
9848 return NULL;
9849 }
9850
9851
9852 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9853 PyObject *resultobj = 0;
9854 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9855 int arg2 ;
9856 wxString result;
9857 void *argp1 = 0 ;
9858 int res1 = 0 ;
9859 int val2 ;
9860 int ecode2 = 0 ;
9861 PyObject * obj0 = 0 ;
9862 PyObject * obj1 = 0 ;
9863 char * kwnames[] = {
9864 (char *) "self",(char *) "i", NULL
9865 };
9866
9867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9869 if (!SWIG_IsOK(res1)) {
9870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9871 }
9872 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9873 ecode2 = SWIG_AsVal_int(obj1, &val2);
9874 if (!SWIG_IsOK(ecode2)) {
9875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9876 }
9877 arg2 = static_cast< int >(val2);
9878 {
9879 PyThreadState* __tstate = wxPyBeginAllowThreads();
9880 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9881 wxPyEndAllowThreads(__tstate);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 {
9885 #if wxUSE_UNICODE
9886 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9887 #else
9888 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9889 #endif
9890 }
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 PyObject *resultobj = 0;
9899 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9900 int result;
9901 void *argp1 = 0 ;
9902 int res1 = 0 ;
9903 PyObject *swig_obj[1] ;
9904
9905 if (!args) SWIG_fail;
9906 swig_obj[0] = args;
9907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9908 if (!SWIG_IsOK(res1)) {
9909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9910 }
9911 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 result = (int)((wxFileHistory const *)arg1)->GetCount();
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 resultobj = SWIG_From_int(static_cast< int >(result));
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9926 PyObject *obj;
9927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9928 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9929 return SWIG_Py_Void();
9930 }
9931
9932 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9933 return SWIG_Python_InitShadowInstance(args);
9934 }
9935
9936 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9937 PyObject *resultobj = 0;
9938 wxString *arg1 = 0 ;
9939 wxString const &arg2_defvalue = wxPyEmptyString ;
9940 wxString *arg2 = (wxString *) &arg2_defvalue ;
9941 wxSingleInstanceChecker *result = 0 ;
9942 bool temp1 = false ;
9943 bool temp2 = false ;
9944 PyObject * obj0 = 0 ;
9945 PyObject * obj1 = 0 ;
9946 char * kwnames[] = {
9947 (char *) "name",(char *) "path", NULL
9948 };
9949
9950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9951 {
9952 arg1 = wxString_in_helper(obj0);
9953 if (arg1 == NULL) SWIG_fail;
9954 temp1 = true;
9955 }
9956 if (obj1) {
9957 {
9958 arg2 = wxString_in_helper(obj1);
9959 if (arg2 == NULL) SWIG_fail;
9960 temp2 = true;
9961 }
9962 }
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9966 wxPyEndAllowThreads(__tstate);
9967 if (PyErr_Occurred()) SWIG_fail;
9968 }
9969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9970 {
9971 if (temp1)
9972 delete arg1;
9973 }
9974 {
9975 if (temp2)
9976 delete arg2;
9977 }
9978 return resultobj;
9979 fail:
9980 {
9981 if (temp1)
9982 delete arg1;
9983 }
9984 {
9985 if (temp2)
9986 delete arg2;
9987 }
9988 return NULL;
9989 }
9990
9991
9992 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9993 PyObject *resultobj = 0;
9994 wxSingleInstanceChecker *result = 0 ;
9995
9996 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9997 {
9998 PyThreadState* __tstate = wxPyBeginAllowThreads();
9999 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
10000 wxPyEndAllowThreads(__tstate);
10001 if (PyErr_Occurred()) SWIG_fail;
10002 }
10003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
10004 return resultobj;
10005 fail:
10006 return NULL;
10007 }
10008
10009
10010 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10011 PyObject *resultobj = 0;
10012 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10013 void *argp1 = 0 ;
10014 int res1 = 0 ;
10015 PyObject *swig_obj[1] ;
10016
10017 if (!args) SWIG_fail;
10018 swig_obj[0] = args;
10019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
10020 if (!SWIG_IsOK(res1)) {
10021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10022 }
10023 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10024 {
10025 PyThreadState* __tstate = wxPyBeginAllowThreads();
10026 delete arg1;
10027
10028 wxPyEndAllowThreads(__tstate);
10029 if (PyErr_Occurred()) SWIG_fail;
10030 }
10031 resultobj = SWIG_Py_Void();
10032 return resultobj;
10033 fail:
10034 return NULL;
10035 }
10036
10037
10038 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10039 PyObject *resultobj = 0;
10040 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10041 wxString *arg2 = 0 ;
10042 wxString const &arg3_defvalue = wxPyEmptyString ;
10043 wxString *arg3 = (wxString *) &arg3_defvalue ;
10044 bool result;
10045 void *argp1 = 0 ;
10046 int res1 = 0 ;
10047 bool temp2 = false ;
10048 bool temp3 = false ;
10049 PyObject * obj0 = 0 ;
10050 PyObject * obj1 = 0 ;
10051 PyObject * obj2 = 0 ;
10052 char * kwnames[] = {
10053 (char *) "self",(char *) "name",(char *) "path", NULL
10054 };
10055
10056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10058 if (!SWIG_IsOK(res1)) {
10059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
10060 }
10061 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10062 {
10063 arg2 = wxString_in_helper(obj1);
10064 if (arg2 == NULL) SWIG_fail;
10065 temp2 = true;
10066 }
10067 if (obj2) {
10068 {
10069 arg3 = wxString_in_helper(obj2);
10070 if (arg3 == NULL) SWIG_fail;
10071 temp3 = true;
10072 }
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 {
10081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10082 }
10083 {
10084 if (temp2)
10085 delete arg2;
10086 }
10087 {
10088 if (temp3)
10089 delete arg3;
10090 }
10091 return resultobj;
10092 fail:
10093 {
10094 if (temp2)
10095 delete arg2;
10096 }
10097 {
10098 if (temp3)
10099 delete arg3;
10100 }
10101 return NULL;
10102 }
10103
10104
10105 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10106 PyObject *resultobj = 0;
10107 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
10108 bool result;
10109 void *argp1 = 0 ;
10110 int res1 = 0 ;
10111 PyObject *swig_obj[1] ;
10112
10113 if (!args) SWIG_fail;
10114 swig_obj[0] = args;
10115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10116 if (!SWIG_IsOK(res1)) {
10117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10118 }
10119 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10123 wxPyEndAllowThreads(__tstate);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 {
10127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10128 }
10129 return resultobj;
10130 fail:
10131 return NULL;
10132 }
10133
10134
10135 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10136 PyObject *obj;
10137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10138 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10139 return SWIG_Py_Void();
10140 }
10141
10142 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10143 return SWIG_Python_InitShadowInstance(args);
10144 }
10145
10146 SWIGINTERN PyObject *_wrap_new_PlatformInformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10147 PyObject *resultobj = 0;
10148 wxPlatformInfo *result = 0 ;
10149
10150 if (!SWIG_Python_UnpackTuple(args,"new_PlatformInformation",0,0,0)) SWIG_fail;
10151 {
10152 PyThreadState* __tstate = wxPyBeginAllowThreads();
10153 result = (wxPlatformInfo *)new wxPlatformInfo();
10154 wxPyEndAllowThreads(__tstate);
10155 if (PyErr_Occurred()) SWIG_fail;
10156 }
10157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPlatformInfo, SWIG_POINTER_NEW | 0 );
10158 return resultobj;
10159 fail:
10160 return NULL;
10161 }
10162
10163
10164 SWIGINTERN PyObject *_wrap_PlatformInformation___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10165 PyObject *resultobj = 0;
10166 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10167 wxPlatformInfo *arg2 = 0 ;
10168 bool result;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 void *argp2 = 0 ;
10172 int res2 = 0 ;
10173 PyObject * obj0 = 0 ;
10174 PyObject * obj1 = 0 ;
10175 char * kwnames[] = {
10176 (char *) "self",(char *) "t", NULL
10177 };
10178
10179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10181 if (!SWIG_IsOK(res1)) {
10182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___eq__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10183 }
10184 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10185 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10186 if (!SWIG_IsOK(res2)) {
10187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10188 }
10189 if (!argp2) {
10190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___eq__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10191 }
10192 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10193 {
10194 PyThreadState* __tstate = wxPyBeginAllowThreads();
10195 result = (bool)((wxPlatformInfo const *)arg1)->operator ==((wxPlatformInfo const &)*arg2);
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 {
10200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10201 }
10202 return resultobj;
10203 fail:
10204 return NULL;
10205 }
10206
10207
10208 SWIGINTERN PyObject *_wrap_PlatformInformation___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10209 PyObject *resultobj = 0;
10210 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10211 wxPlatformInfo *arg2 = 0 ;
10212 bool result;
10213 void *argp1 = 0 ;
10214 int res1 = 0 ;
10215 void *argp2 = 0 ;
10216 int res2 = 0 ;
10217 PyObject * obj0 = 0 ;
10218 PyObject * obj1 = 0 ;
10219 char * kwnames[] = {
10220 (char *) "self",(char *) "t", NULL
10221 };
10222
10223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10225 if (!SWIG_IsOK(res1)) {
10226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation___ne__" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10227 }
10228 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10229 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPlatformInfo, 0 | 0);
10230 if (!SWIG_IsOK(res2)) {
10231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10232 }
10233 if (!argp2) {
10234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PlatformInformation___ne__" "', expected argument " "2"" of type '" "wxPlatformInfo const &""'");
10235 }
10236 arg2 = reinterpret_cast< wxPlatformInfo * >(argp2);
10237 {
10238 PyThreadState* __tstate = wxPyBeginAllowThreads();
10239 result = (bool)((wxPlatformInfo const *)arg1)->operator !=((wxPlatformInfo const &)*arg2);
10240 wxPyEndAllowThreads(__tstate);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 {
10244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10245 }
10246 return resultobj;
10247 fail:
10248 return NULL;
10249 }
10250
10251
10252 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10253 PyObject *resultobj = 0;
10254 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10255 int result;
10256 void *argp1 = 0 ;
10257 int res1 = 0 ;
10258 PyObject *swig_obj[1] ;
10259
10260 if (!args) SWIG_fail;
10261 swig_obj[0] = args;
10262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10263 if (!SWIG_IsOK(res1)) {
10264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10265 }
10266 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10267 {
10268 PyThreadState* __tstate = wxPyBeginAllowThreads();
10269 result = (int)((wxPlatformInfo const *)arg1)->GetOSMajorVersion();
10270 wxPyEndAllowThreads(__tstate);
10271 if (PyErr_Occurred()) SWIG_fail;
10272 }
10273 resultobj = SWIG_From_int(static_cast< int >(result));
10274 return resultobj;
10275 fail:
10276 return NULL;
10277 }
10278
10279
10280 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOSMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10281 PyObject *resultobj = 0;
10282 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10283 int result;
10284 void *argp1 = 0 ;
10285 int res1 = 0 ;
10286 PyObject *swig_obj[1] ;
10287
10288 if (!args) SWIG_fail;
10289 swig_obj[0] = args;
10290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10291 if (!SWIG_IsOK(res1)) {
10292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOSMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10293 }
10294 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10295 {
10296 PyThreadState* __tstate = wxPyBeginAllowThreads();
10297 result = (int)((wxPlatformInfo const *)arg1)->GetOSMinorVersion();
10298 wxPyEndAllowThreads(__tstate);
10299 if (PyErr_Occurred()) SWIG_fail;
10300 }
10301 resultobj = SWIG_From_int(static_cast< int >(result));
10302 return resultobj;
10303 fail:
10304 return NULL;
10305 }
10306
10307
10308 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10309 PyObject *resultobj = 0;
10310 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10311 int arg2 ;
10312 int arg3 ;
10313 bool result;
10314 void *argp1 = 0 ;
10315 int res1 = 0 ;
10316 int val2 ;
10317 int ecode2 = 0 ;
10318 int val3 ;
10319 int ecode3 = 0 ;
10320 PyObject * obj0 = 0 ;
10321 PyObject * obj1 = 0 ;
10322 PyObject * obj2 = 0 ;
10323 char * kwnames[] = {
10324 (char *) "self",(char *) "major",(char *) "minor", NULL
10325 };
10326
10327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10329 if (!SWIG_IsOK(res1)) {
10330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10331 }
10332 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10333 ecode2 = SWIG_AsVal_int(obj1, &val2);
10334 if (!SWIG_IsOK(ecode2)) {
10335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "2"" of type '" "int""'");
10336 }
10337 arg2 = static_cast< int >(val2);
10338 ecode3 = SWIG_AsVal_int(obj2, &val3);
10339 if (!SWIG_IsOK(ecode3)) {
10340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckOSVersion" "', expected argument " "3"" of type '" "int""'");
10341 }
10342 arg3 = static_cast< int >(val3);
10343 {
10344 PyThreadState* __tstate = wxPyBeginAllowThreads();
10345 result = (bool)((wxPlatformInfo const *)arg1)->CheckOSVersion(arg2,arg3);
10346 wxPyEndAllowThreads(__tstate);
10347 if (PyErr_Occurred()) SWIG_fail;
10348 }
10349 {
10350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10351 }
10352 return resultobj;
10353 fail:
10354 return NULL;
10355 }
10356
10357
10358 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMajorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10359 PyObject *resultobj = 0;
10360 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10361 int result;
10362 void *argp1 = 0 ;
10363 int res1 = 0 ;
10364 PyObject *swig_obj[1] ;
10365
10366 if (!args) SWIG_fail;
10367 swig_obj[0] = args;
10368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10369 if (!SWIG_IsOK(res1)) {
10370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMajorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10371 }
10372 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMajorVersion();
10376 wxPyEndAllowThreads(__tstate);
10377 if (PyErr_Occurred()) SWIG_fail;
10378 }
10379 resultobj = SWIG_From_int(static_cast< int >(result));
10380 return resultobj;
10381 fail:
10382 return NULL;
10383 }
10384
10385
10386 SWIGINTERN PyObject *_wrap_PlatformInformation_GetToolkitMinorVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10387 PyObject *resultobj = 0;
10388 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10389 int result;
10390 void *argp1 = 0 ;
10391 int res1 = 0 ;
10392 PyObject *swig_obj[1] ;
10393
10394 if (!args) SWIG_fail;
10395 swig_obj[0] = args;
10396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10397 if (!SWIG_IsOK(res1)) {
10398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetToolkitMinorVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10399 }
10400 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10401 {
10402 PyThreadState* __tstate = wxPyBeginAllowThreads();
10403 result = (int)((wxPlatformInfo const *)arg1)->GetToolkitMinorVersion();
10404 wxPyEndAllowThreads(__tstate);
10405 if (PyErr_Occurred()) SWIG_fail;
10406 }
10407 resultobj = SWIG_From_int(static_cast< int >(result));
10408 return resultobj;
10409 fail:
10410 return NULL;
10411 }
10412
10413
10414 SWIGINTERN PyObject *_wrap_PlatformInformation_CheckToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10415 PyObject *resultobj = 0;
10416 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10417 int arg2 ;
10418 int arg3 ;
10419 bool result;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 int val2 ;
10423 int ecode2 = 0 ;
10424 int val3 ;
10425 int ecode3 = 0 ;
10426 PyObject * obj0 = 0 ;
10427 PyObject * obj1 = 0 ;
10428 PyObject * obj2 = 0 ;
10429 char * kwnames[] = {
10430 (char *) "self",(char *) "major",(char *) "minor", NULL
10431 };
10432
10433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_CheckToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10435 if (!SWIG_IsOK(res1)) {
10436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10437 }
10438 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10439 ecode2 = SWIG_AsVal_int(obj1, &val2);
10440 if (!SWIG_IsOK(ecode2)) {
10441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10442 }
10443 arg2 = static_cast< int >(val2);
10444 ecode3 = SWIG_AsVal_int(obj2, &val3);
10445 if (!SWIG_IsOK(ecode3)) {
10446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_CheckToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10447 }
10448 arg3 = static_cast< int >(val3);
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (bool)((wxPlatformInfo const *)arg1)->CheckToolkitVersion(arg2,arg3);
10452 wxPyEndAllowThreads(__tstate);
10453 if (PyErr_Occurred()) SWIG_fail;
10454 }
10455 {
10456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10457 }
10458 return resultobj;
10459 fail:
10460 return NULL;
10461 }
10462
10463
10464 SWIGINTERN PyObject *_wrap_PlatformInformation_IsUsingUniversalWidgets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10465 PyObject *resultobj = 0;
10466 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10467 bool result;
10468 void *argp1 = 0 ;
10469 int res1 = 0 ;
10470 PyObject *swig_obj[1] ;
10471
10472 if (!args) SWIG_fail;
10473 swig_obj[0] = args;
10474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10475 if (!SWIG_IsOK(res1)) {
10476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsUsingUniversalWidgets" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10477 }
10478 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10479 {
10480 PyThreadState* __tstate = wxPyBeginAllowThreads();
10481 result = (bool)((wxPlatformInfo const *)arg1)->IsUsingUniversalWidgets();
10482 wxPyEndAllowThreads(__tstate);
10483 if (PyErr_Occurred()) SWIG_fail;
10484 }
10485 {
10486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10487 }
10488 return resultobj;
10489 fail:
10490 return NULL;
10491 }
10492
10493
10494 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10495 PyObject *resultobj = 0;
10496 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10497 wxOperatingSystemId result;
10498 void *argp1 = 0 ;
10499 int res1 = 0 ;
10500 PyObject *swig_obj[1] ;
10501
10502 if (!args) SWIG_fail;
10503 swig_obj[0] = args;
10504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10505 if (!SWIG_IsOK(res1)) {
10506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10507 }
10508 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10509 {
10510 PyThreadState* __tstate = wxPyBeginAllowThreads();
10511 result = (wxOperatingSystemId)((wxPlatformInfo const *)arg1)->GetOperatingSystemId();
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 resultobj = SWIG_From_int(static_cast< int >(result));
10516 return resultobj;
10517 fail:
10518 return NULL;
10519 }
10520
10521
10522 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10523 PyObject *resultobj = 0;
10524 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10525 wxPortId result;
10526 void *argp1 = 0 ;
10527 int res1 = 0 ;
10528 PyObject *swig_obj[1] ;
10529
10530 if (!args) SWIG_fail;
10531 swig_obj[0] = args;
10532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10533 if (!SWIG_IsOK(res1)) {
10534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10535 }
10536 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 result = (wxPortId)((wxPlatformInfo const *)arg1)->GetPortId();
10540 wxPyEndAllowThreads(__tstate);
10541 if (PyErr_Occurred()) SWIG_fail;
10542 }
10543 resultobj = SWIG_From_int(static_cast< int >(result));
10544 return resultobj;
10545 fail:
10546 return NULL;
10547 }
10548
10549
10550 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10551 PyObject *resultobj = 0;
10552 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10553 wxArchitecture result;
10554 void *argp1 = 0 ;
10555 int res1 = 0 ;
10556 PyObject *swig_obj[1] ;
10557
10558 if (!args) SWIG_fail;
10559 swig_obj[0] = args;
10560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10561 if (!SWIG_IsOK(res1)) {
10562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10563 }
10564 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10565 {
10566 PyThreadState* __tstate = wxPyBeginAllowThreads();
10567 result = (wxArchitecture)((wxPlatformInfo const *)arg1)->GetArchitecture();
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 resultobj = SWIG_From_int(static_cast< int >(result));
10572 return resultobj;
10573 fail:
10574 return NULL;
10575 }
10576
10577
10578 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10579 PyObject *resultobj = 0;
10580 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10581 wxEndianness result;
10582 void *argp1 = 0 ;
10583 int res1 = 0 ;
10584 PyObject *swig_obj[1] ;
10585
10586 if (!args) SWIG_fail;
10587 swig_obj[0] = args;
10588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10589 if (!SWIG_IsOK(res1)) {
10590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10591 }
10592 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (wxEndianness)((wxPlatformInfo const *)arg1)->GetEndianness();
10596 wxPyEndAllowThreads(__tstate);
10597 if (PyErr_Occurred()) SWIG_fail;
10598 }
10599 resultobj = SWIG_From_int(static_cast< int >(result));
10600 return resultobj;
10601 fail:
10602 return NULL;
10603 }
10604
10605
10606 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemFamilyName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10607 PyObject *resultobj = 0;
10608 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10609 wxString result;
10610 void *argp1 = 0 ;
10611 int res1 = 0 ;
10612 PyObject *swig_obj[1] ;
10613
10614 if (!args) SWIG_fail;
10615 swig_obj[0] = args;
10616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10617 if (!SWIG_IsOK(res1)) {
10618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemFamilyName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10619 }
10620 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10621 {
10622 PyThreadState* __tstate = wxPyBeginAllowThreads();
10623 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemFamilyName();
10624 wxPyEndAllowThreads(__tstate);
10625 if (PyErr_Occurred()) SWIG_fail;
10626 }
10627 {
10628 #if wxUSE_UNICODE
10629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10630 #else
10631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10632 #endif
10633 }
10634 return resultobj;
10635 fail:
10636 return NULL;
10637 }
10638
10639
10640 SWIGINTERN PyObject *_wrap_PlatformInformation_GetOperatingSystemIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10641 PyObject *resultobj = 0;
10642 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10643 wxString result;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 PyObject *swig_obj[1] ;
10647
10648 if (!args) SWIG_fail;
10649 swig_obj[0] = args;
10650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10651 if (!SWIG_IsOK(res1)) {
10652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetOperatingSystemIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10653 }
10654 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 result = ((wxPlatformInfo const *)arg1)->GetOperatingSystemIdName();
10658 wxPyEndAllowThreads(__tstate);
10659 if (PyErr_Occurred()) SWIG_fail;
10660 }
10661 {
10662 #if wxUSE_UNICODE
10663 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10664 #else
10665 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10666 #endif
10667 }
10668 return resultobj;
10669 fail:
10670 return NULL;
10671 }
10672
10673
10674 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10675 PyObject *resultobj = 0;
10676 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10677 wxString result;
10678 void *argp1 = 0 ;
10679 int res1 = 0 ;
10680 PyObject *swig_obj[1] ;
10681
10682 if (!args) SWIG_fail;
10683 swig_obj[0] = args;
10684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10685 if (!SWIG_IsOK(res1)) {
10686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10687 }
10688 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10689 {
10690 PyThreadState* __tstate = wxPyBeginAllowThreads();
10691 result = ((wxPlatformInfo const *)arg1)->GetPortIdName();
10692 wxPyEndAllowThreads(__tstate);
10693 if (PyErr_Occurred()) SWIG_fail;
10694 }
10695 {
10696 #if wxUSE_UNICODE
10697 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10698 #else
10699 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10700 #endif
10701 }
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 SWIGINTERN PyObject *_wrap_PlatformInformation_GetPortIdShortName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10709 PyObject *resultobj = 0;
10710 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10711 wxString result;
10712 void *argp1 = 0 ;
10713 int res1 = 0 ;
10714 PyObject *swig_obj[1] ;
10715
10716 if (!args) SWIG_fail;
10717 swig_obj[0] = args;
10718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10719 if (!SWIG_IsOK(res1)) {
10720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetPortIdShortName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10721 }
10722 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10723 {
10724 PyThreadState* __tstate = wxPyBeginAllowThreads();
10725 result = ((wxPlatformInfo const *)arg1)->GetPortIdShortName();
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 {
10730 #if wxUSE_UNICODE
10731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10732 #else
10733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10734 #endif
10735 }
10736 return resultobj;
10737 fail:
10738 return NULL;
10739 }
10740
10741
10742 SWIGINTERN PyObject *_wrap_PlatformInformation_GetArchName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10743 PyObject *resultobj = 0;
10744 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10745 wxString result;
10746 void *argp1 = 0 ;
10747 int res1 = 0 ;
10748 PyObject *swig_obj[1] ;
10749
10750 if (!args) SWIG_fail;
10751 swig_obj[0] = args;
10752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10753 if (!SWIG_IsOK(res1)) {
10754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetArchName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10755 }
10756 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 result = ((wxPlatformInfo const *)arg1)->GetArchName();
10760 wxPyEndAllowThreads(__tstate);
10761 if (PyErr_Occurred()) SWIG_fail;
10762 }
10763 {
10764 #if wxUSE_UNICODE
10765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10766 #else
10767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10768 #endif
10769 }
10770 return resultobj;
10771 fail:
10772 return NULL;
10773 }
10774
10775
10776 SWIGINTERN PyObject *_wrap_PlatformInformation_GetEndiannessName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10777 PyObject *resultobj = 0;
10778 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10779 wxString result;
10780 void *argp1 = 0 ;
10781 int res1 = 0 ;
10782 PyObject *swig_obj[1] ;
10783
10784 if (!args) SWIG_fail;
10785 swig_obj[0] = args;
10786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10787 if (!SWIG_IsOK(res1)) {
10788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_GetEndiannessName" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
10789 }
10790 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10791 {
10792 PyThreadState* __tstate = wxPyBeginAllowThreads();
10793 result = ((wxPlatformInfo const *)arg1)->GetEndiannessName();
10794 wxPyEndAllowThreads(__tstate);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 {
10798 #if wxUSE_UNICODE
10799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10800 #else
10801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10802 #endif
10803 }
10804 return resultobj;
10805 fail:
10806 return NULL;
10807 }
10808
10809
10810 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOSVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10811 PyObject *resultobj = 0;
10812 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10813 int arg2 ;
10814 int arg3 ;
10815 void *argp1 = 0 ;
10816 int res1 = 0 ;
10817 int val2 ;
10818 int ecode2 = 0 ;
10819 int val3 ;
10820 int ecode3 = 0 ;
10821 PyObject * obj0 = 0 ;
10822 PyObject * obj1 = 0 ;
10823 PyObject * obj2 = 0 ;
10824 char * kwnames[] = {
10825 (char *) "self",(char *) "major",(char *) "minor", NULL
10826 };
10827
10828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetOSVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10830 if (!SWIG_IsOK(res1)) {
10831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10832 }
10833 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10834 ecode2 = SWIG_AsVal_int(obj1, &val2);
10835 if (!SWIG_IsOK(ecode2)) {
10836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "2"" of type '" "int""'");
10837 }
10838 arg2 = static_cast< int >(val2);
10839 ecode3 = SWIG_AsVal_int(obj2, &val3);
10840 if (!SWIG_IsOK(ecode3)) {
10841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetOSVersion" "', expected argument " "3"" of type '" "int""'");
10842 }
10843 arg3 = static_cast< int >(val3);
10844 {
10845 PyThreadState* __tstate = wxPyBeginAllowThreads();
10846 (arg1)->SetOSVersion(arg2,arg3);
10847 wxPyEndAllowThreads(__tstate);
10848 if (PyErr_Occurred()) SWIG_fail;
10849 }
10850 resultobj = SWIG_Py_Void();
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 SWIGINTERN PyObject *_wrap_PlatformInformation_SetToolkitVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj = 0;
10859 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10860 int arg2 ;
10861 int arg3 ;
10862 void *argp1 = 0 ;
10863 int res1 = 0 ;
10864 int val2 ;
10865 int ecode2 = 0 ;
10866 int val3 ;
10867 int ecode3 = 0 ;
10868 PyObject * obj0 = 0 ;
10869 PyObject * obj1 = 0 ;
10870 PyObject * obj2 = 0 ;
10871 char * kwnames[] = {
10872 (char *) "self",(char *) "major",(char *) "minor", NULL
10873 };
10874
10875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PlatformInformation_SetToolkitVersion",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10877 if (!SWIG_IsOK(res1)) {
10878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10879 }
10880 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10881 ecode2 = SWIG_AsVal_int(obj1, &val2);
10882 if (!SWIG_IsOK(ecode2)) {
10883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "2"" of type '" "int""'");
10884 }
10885 arg2 = static_cast< int >(val2);
10886 ecode3 = SWIG_AsVal_int(obj2, &val3);
10887 if (!SWIG_IsOK(ecode3)) {
10888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PlatformInformation_SetToolkitVersion" "', expected argument " "3"" of type '" "int""'");
10889 }
10890 arg3 = static_cast< int >(val3);
10891 {
10892 PyThreadState* __tstate = wxPyBeginAllowThreads();
10893 (arg1)->SetToolkitVersion(arg2,arg3);
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 resultobj = SWIG_Py_Void();
10898 return resultobj;
10899 fail:
10900 return NULL;
10901 }
10902
10903
10904 SWIGINTERN PyObject *_wrap_PlatformInformation_SetOperatingSystemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10905 PyObject *resultobj = 0;
10906 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10907 wxOperatingSystemId arg2 ;
10908 void *argp1 = 0 ;
10909 int res1 = 0 ;
10910 int val2 ;
10911 int ecode2 = 0 ;
10912 PyObject * obj0 = 0 ;
10913 PyObject * obj1 = 0 ;
10914 char * kwnames[] = {
10915 (char *) "self",(char *) "n", NULL
10916 };
10917
10918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetOperatingSystemId",kwnames,&obj0,&obj1)) SWIG_fail;
10919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10920 if (!SWIG_IsOK(res1)) {
10921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10922 }
10923 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10924 ecode2 = SWIG_AsVal_int(obj1, &val2);
10925 if (!SWIG_IsOK(ecode2)) {
10926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetOperatingSystemId" "', expected argument " "2"" of type '" "wxOperatingSystemId""'");
10927 }
10928 arg2 = static_cast< wxOperatingSystemId >(val2);
10929 {
10930 PyThreadState* __tstate = wxPyBeginAllowThreads();
10931 (arg1)->SetOperatingSystemId(arg2);
10932 wxPyEndAllowThreads(__tstate);
10933 if (PyErr_Occurred()) SWIG_fail;
10934 }
10935 resultobj = SWIG_Py_Void();
10936 return resultobj;
10937 fail:
10938 return NULL;
10939 }
10940
10941
10942 SWIGINTERN PyObject *_wrap_PlatformInformation_SetPortId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10943 PyObject *resultobj = 0;
10944 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10945 wxPortId arg2 ;
10946 void *argp1 = 0 ;
10947 int res1 = 0 ;
10948 int val2 ;
10949 int ecode2 = 0 ;
10950 PyObject * obj0 = 0 ;
10951 PyObject * obj1 = 0 ;
10952 char * kwnames[] = {
10953 (char *) "self",(char *) "n", NULL
10954 };
10955
10956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetPortId",kwnames,&obj0,&obj1)) SWIG_fail;
10957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10958 if (!SWIG_IsOK(res1)) {
10959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetPortId" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10960 }
10961 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
10962 ecode2 = SWIG_AsVal_int(obj1, &val2);
10963 if (!SWIG_IsOK(ecode2)) {
10964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetPortId" "', expected argument " "2"" of type '" "wxPortId""'");
10965 }
10966 arg2 = static_cast< wxPortId >(val2);
10967 {
10968 PyThreadState* __tstate = wxPyBeginAllowThreads();
10969 (arg1)->SetPortId(arg2);
10970 wxPyEndAllowThreads(__tstate);
10971 if (PyErr_Occurred()) SWIG_fail;
10972 }
10973 resultobj = SWIG_Py_Void();
10974 return resultobj;
10975 fail:
10976 return NULL;
10977 }
10978
10979
10980 SWIGINTERN PyObject *_wrap_PlatformInformation_SetArchitecture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj = 0;
10982 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
10983 wxArchitecture arg2 ;
10984 void *argp1 = 0 ;
10985 int res1 = 0 ;
10986 int val2 ;
10987 int ecode2 = 0 ;
10988 PyObject * obj0 = 0 ;
10989 PyObject * obj1 = 0 ;
10990 char * kwnames[] = {
10991 (char *) "self",(char *) "n", NULL
10992 };
10993
10994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetArchitecture",kwnames,&obj0,&obj1)) SWIG_fail;
10995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
10996 if (!SWIG_IsOK(res1)) {
10997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
10998 }
10999 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11000 ecode2 = SWIG_AsVal_int(obj1, &val2);
11001 if (!SWIG_IsOK(ecode2)) {
11002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetArchitecture" "', expected argument " "2"" of type '" "wxArchitecture""'");
11003 }
11004 arg2 = static_cast< wxArchitecture >(val2);
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 (arg1)->SetArchitecture(arg2);
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 resultobj = SWIG_Py_Void();
11012 return resultobj;
11013 fail:
11014 return NULL;
11015 }
11016
11017
11018 SWIGINTERN PyObject *_wrap_PlatformInformation_SetEndianness(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11019 PyObject *resultobj = 0;
11020 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11021 wxEndianness arg2 ;
11022 void *argp1 = 0 ;
11023 int res1 = 0 ;
11024 int val2 ;
11025 int ecode2 = 0 ;
11026 PyObject * obj0 = 0 ;
11027 PyObject * obj1 = 0 ;
11028 char * kwnames[] = {
11029 (char *) "self",(char *) "n", NULL
11030 };
11031
11032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PlatformInformation_SetEndianness",kwnames,&obj0,&obj1)) SWIG_fail;
11033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11034 if (!SWIG_IsOK(res1)) {
11035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "1"" of type '" "wxPlatformInfo *""'");
11036 }
11037 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11038 ecode2 = SWIG_AsVal_int(obj1, &val2);
11039 if (!SWIG_IsOK(ecode2)) {
11040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlatformInformation_SetEndianness" "', expected argument " "2"" of type '" "wxEndianness""'");
11041 }
11042 arg2 = static_cast< wxEndianness >(val2);
11043 {
11044 PyThreadState* __tstate = wxPyBeginAllowThreads();
11045 (arg1)->SetEndianness(arg2);
11046 wxPyEndAllowThreads(__tstate);
11047 if (PyErr_Occurred()) SWIG_fail;
11048 }
11049 resultobj = SWIG_Py_Void();
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *_wrap_PlatformInformation_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11057 PyObject *resultobj = 0;
11058 wxPlatformInfo *arg1 = (wxPlatformInfo *) 0 ;
11059 bool result;
11060 void *argp1 = 0 ;
11061 int res1 = 0 ;
11062 PyObject *swig_obj[1] ;
11063
11064 if (!args) SWIG_fail;
11065 swig_obj[0] = args;
11066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPlatformInfo, 0 | 0 );
11067 if (!SWIG_IsOK(res1)) {
11068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlatformInformation_IsOk" "', expected argument " "1"" of type '" "wxPlatformInfo const *""'");
11069 }
11070 arg1 = reinterpret_cast< wxPlatformInfo * >(argp1);
11071 {
11072 PyThreadState* __tstate = wxPyBeginAllowThreads();
11073 result = (bool)((wxPlatformInfo const *)arg1)->IsOk();
11074 wxPyEndAllowThreads(__tstate);
11075 if (PyErr_Occurred()) SWIG_fail;
11076 }
11077 {
11078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11079 }
11080 return resultobj;
11081 fail:
11082 return NULL;
11083 }
11084
11085
11086 SWIGINTERN PyObject *PlatformInformation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11087 PyObject *obj;
11088 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11089 SWIG_TypeNewClientData(SWIGTYPE_p_wxPlatformInfo, SWIG_NewClientData(obj));
11090 return SWIG_Py_Void();
11091 }
11092
11093 SWIGINTERN PyObject *PlatformInformation_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11094 return SWIG_Python_InitShadowInstance(args);
11095 }
11096
11097 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj = 0;
11099 wxWindow *arg1 = (wxWindow *) 0 ;
11100 wxDC *arg2 = 0 ;
11101 bool result;
11102 void *argp1 = 0 ;
11103 int res1 = 0 ;
11104 void *argp2 = 0 ;
11105 int res2 = 0 ;
11106 PyObject * obj0 = 0 ;
11107 PyObject * obj1 = 0 ;
11108 char * kwnames[] = {
11109 (char *) "window",(char *) "dc", NULL
11110 };
11111
11112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
11113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11114 if (!SWIG_IsOK(res1)) {
11115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
11116 }
11117 arg1 = reinterpret_cast< wxWindow * >(argp1);
11118 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
11119 if (!SWIG_IsOK(res2)) {
11120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11121 }
11122 if (!argp2) {
11123 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
11124 }
11125 arg2 = reinterpret_cast< wxDC * >(argp2);
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
11129 wxPyEndAllowThreads(__tstate);
11130 if (PyErr_Occurred()) SWIG_fail;
11131 }
11132 {
11133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11134 }
11135 return resultobj;
11136 fail:
11137 return NULL;
11138 }
11139
11140
11141 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11142 PyObject *resultobj = 0;
11143 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11144 void *argp1 = 0 ;
11145 int res1 = 0 ;
11146 PyObject *swig_obj[1] ;
11147
11148 if (!args) SWIG_fail;
11149 swig_obj[0] = args;
11150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
11151 if (!SWIG_IsOK(res1)) {
11152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11153 }
11154 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11155 {
11156 PyThreadState* __tstate = wxPyBeginAllowThreads();
11157 delete arg1;
11158
11159 wxPyEndAllowThreads(__tstate);
11160 if (PyErr_Occurred()) SWIG_fail;
11161 }
11162 resultobj = SWIG_Py_Void();
11163 return resultobj;
11164 fail:
11165 return NULL;
11166 }
11167
11168
11169 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11170 PyObject *resultobj = 0;
11171 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11172 wxString result;
11173 void *argp1 = 0 ;
11174 int res1 = 0 ;
11175 PyObject *swig_obj[1] ;
11176
11177 if (!args) SWIG_fail;
11178 swig_obj[0] = args;
11179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11180 if (!SWIG_IsOK(res1)) {
11181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11182 }
11183 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (arg1)->GetTip();
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 {
11191 #if wxUSE_UNICODE
11192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11193 #else
11194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11195 #endif
11196 }
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11204 PyObject *resultobj = 0;
11205 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11206 size_t result;
11207 void *argp1 = 0 ;
11208 int res1 = 0 ;
11209 PyObject *swig_obj[1] ;
11210
11211 if (!args) SWIG_fail;
11212 swig_obj[0] = args;
11213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11214 if (!SWIG_IsOK(res1)) {
11215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11216 }
11217 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11218 {
11219 PyThreadState* __tstate = wxPyBeginAllowThreads();
11220 result = (size_t)(arg1)->GetCurrentTip();
11221 wxPyEndAllowThreads(__tstate);
11222 if (PyErr_Occurred()) SWIG_fail;
11223 }
11224 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11225 return resultobj;
11226 fail:
11227 return NULL;
11228 }
11229
11230
11231 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11232 PyObject *resultobj = 0;
11233 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
11234 wxString *arg2 = 0 ;
11235 wxString result;
11236 void *argp1 = 0 ;
11237 int res1 = 0 ;
11238 bool temp2 = false ;
11239 PyObject * obj0 = 0 ;
11240 PyObject * obj1 = 0 ;
11241 char * kwnames[] = {
11242 (char *) "self",(char *) "tip", NULL
11243 };
11244
11245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
11246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11247 if (!SWIG_IsOK(res1)) {
11248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
11249 }
11250 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
11251 {
11252 arg2 = wxString_in_helper(obj1);
11253 if (arg2 == NULL) SWIG_fail;
11254 temp2 = true;
11255 }
11256 {
11257 PyThreadState* __tstate = wxPyBeginAllowThreads();
11258 result = (arg1)->PreprocessTip((wxString const &)*arg2);
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 {
11263 #if wxUSE_UNICODE
11264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11265 #else
11266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11267 #endif
11268 }
11269 {
11270 if (temp2)
11271 delete arg2;
11272 }
11273 return resultobj;
11274 fail:
11275 {
11276 if (temp2)
11277 delete arg2;
11278 }
11279 return NULL;
11280 }
11281
11282
11283 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11284 PyObject *obj;
11285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11286 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
11287 return SWIG_Py_Void();
11288 }
11289
11290 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11291 PyObject *resultobj = 0;
11292 size_t arg1 ;
11293 wxPyTipProvider *result = 0 ;
11294 size_t val1 ;
11295 int ecode1 = 0 ;
11296 PyObject * obj0 = 0 ;
11297 char * kwnames[] = {
11298 (char *) "currentTip", NULL
11299 };
11300
11301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
11302 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
11303 if (!SWIG_IsOK(ecode1)) {
11304 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
11305 }
11306 arg1 = static_cast< size_t >(val1);
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
11310 wxPyEndAllowThreads(__tstate);
11311 if (PyErr_Occurred()) SWIG_fail;
11312 }
11313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
11314 return resultobj;
11315 fail:
11316 return NULL;
11317 }
11318
11319
11320 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj = 0;
11322 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
11323 PyObject *arg2 = (PyObject *) 0 ;
11324 PyObject *arg3 = (PyObject *) 0 ;
11325 void *argp1 = 0 ;
11326 int res1 = 0 ;
11327 PyObject * obj0 = 0 ;
11328 PyObject * obj1 = 0 ;
11329 PyObject * obj2 = 0 ;
11330 char * kwnames[] = {
11331 (char *) "self",(char *) "self",(char *) "_class", NULL
11332 };
11333
11334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
11336 if (!SWIG_IsOK(res1)) {
11337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
11338 }
11339 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
11340 arg2 = obj1;
11341 arg3 = obj2;
11342 {
11343 PyThreadState* __tstate = wxPyBeginAllowThreads();
11344 (arg1)->_setCallbackInfo(arg2,arg3);
11345 wxPyEndAllowThreads(__tstate);
11346 if (PyErr_Occurred()) SWIG_fail;
11347 }
11348 resultobj = SWIG_Py_Void();
11349 return resultobj;
11350 fail:
11351 return NULL;
11352 }
11353
11354
11355 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11356 PyObject *obj;
11357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11358 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
11359 return SWIG_Py_Void();
11360 }
11361
11362 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11363 return SWIG_Python_InitShadowInstance(args);
11364 }
11365
11366 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11367 PyObject *resultobj = 0;
11368 wxWindow *arg1 = (wxWindow *) 0 ;
11369 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
11370 bool arg3 = (bool) true ;
11371 bool result;
11372 void *argp1 = 0 ;
11373 int res1 = 0 ;
11374 void *argp2 = 0 ;
11375 int res2 = 0 ;
11376 bool val3 ;
11377 int ecode3 = 0 ;
11378 PyObject * obj0 = 0 ;
11379 PyObject * obj1 = 0 ;
11380 PyObject * obj2 = 0 ;
11381 char * kwnames[] = {
11382 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
11383 };
11384
11385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
11387 if (!SWIG_IsOK(res1)) {
11388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
11389 }
11390 arg1 = reinterpret_cast< wxWindow * >(argp1);
11391 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
11392 if (!SWIG_IsOK(res2)) {
11393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
11394 }
11395 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
11396 if (obj2) {
11397 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11398 if (!SWIG_IsOK(ecode3)) {
11399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
11400 }
11401 arg3 = static_cast< bool >(val3);
11402 }
11403 {
11404 if (!wxPyCheckForApp()) SWIG_fail;
11405 PyThreadState* __tstate = wxPyBeginAllowThreads();
11406 result = (bool)wxShowTip(arg1,arg2,arg3);
11407 wxPyEndAllowThreads(__tstate);
11408 if (PyErr_Occurred()) SWIG_fail;
11409 }
11410 {
11411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11412 }
11413 return resultobj;
11414 fail:
11415 return NULL;
11416 }
11417
11418
11419 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11420 PyObject *resultobj = 0;
11421 wxString *arg1 = 0 ;
11422 size_t arg2 ;
11423 wxTipProvider *result = 0 ;
11424 bool temp1 = false ;
11425 size_t val2 ;
11426 int ecode2 = 0 ;
11427 PyObject * obj0 = 0 ;
11428 PyObject * obj1 = 0 ;
11429 char * kwnames[] = {
11430 (char *) "filename",(char *) "currentTip", NULL
11431 };
11432
11433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
11434 {
11435 arg1 = wxString_in_helper(obj0);
11436 if (arg1 == NULL) SWIG_fail;
11437 temp1 = true;
11438 }
11439 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
11440 if (!SWIG_IsOK(ecode2)) {
11441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
11442 }
11443 arg2 = static_cast< size_t >(val2);
11444 {
11445 if (!wxPyCheckForApp()) SWIG_fail;
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
11448 wxPyEndAllowThreads(__tstate);
11449 if (PyErr_Occurred()) SWIG_fail;
11450 }
11451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
11452 {
11453 if (temp1)
11454 delete arg1;
11455 }
11456 return resultobj;
11457 fail:
11458 {
11459 if (temp1)
11460 delete arg1;
11461 }
11462 return NULL;
11463 }
11464
11465
11466 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11467 PyObject *resultobj = 0;
11468 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
11469 int arg2 = (int) wxID_ANY ;
11470 wxPyTimer *result = 0 ;
11471 void *argp1 = 0 ;
11472 int res1 = 0 ;
11473 int val2 ;
11474 int ecode2 = 0 ;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 char * kwnames[] = {
11478 (char *) "owner",(char *) "id", NULL
11479 };
11480
11481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
11482 if (obj0) {
11483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11484 if (!SWIG_IsOK(res1)) {
11485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
11486 }
11487 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
11488 }
11489 if (obj1) {
11490 ecode2 = SWIG_AsVal_int(obj1, &val2);
11491 if (!SWIG_IsOK(ecode2)) {
11492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
11493 }
11494 arg2 = static_cast< int >(val2);
11495 }
11496 {
11497 if (!wxPyCheckForApp()) SWIG_fail;
11498 PyThreadState* __tstate = wxPyBeginAllowThreads();
11499 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
11500 wxPyEndAllowThreads(__tstate);
11501 if (PyErr_Occurred()) SWIG_fail;
11502 }
11503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
11504 return resultobj;
11505 fail:
11506 return NULL;
11507 }
11508
11509
11510 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11511 PyObject *resultobj = 0;
11512 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11513 void *argp1 = 0 ;
11514 int res1 = 0 ;
11515 PyObject *swig_obj[1] ;
11516
11517 if (!args) SWIG_fail;
11518 swig_obj[0] = args;
11519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
11520 if (!SWIG_IsOK(res1)) {
11521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11522 }
11523 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11524 {
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 delete arg1;
11527
11528 wxPyEndAllowThreads(__tstate);
11529 if (PyErr_Occurred()) SWIG_fail;
11530 }
11531 resultobj = SWIG_Py_Void();
11532 return resultobj;
11533 fail:
11534 return NULL;
11535 }
11536
11537
11538 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11539 PyObject *resultobj = 0;
11540 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11541 PyObject *arg2 = (PyObject *) 0 ;
11542 PyObject *arg3 = (PyObject *) 0 ;
11543 int arg4 = (int) 1 ;
11544 void *argp1 = 0 ;
11545 int res1 = 0 ;
11546 int val4 ;
11547 int ecode4 = 0 ;
11548 PyObject * obj0 = 0 ;
11549 PyObject * obj1 = 0 ;
11550 PyObject * obj2 = 0 ;
11551 PyObject * obj3 = 0 ;
11552 char * kwnames[] = {
11553 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
11554 };
11555
11556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11558 if (!SWIG_IsOK(res1)) {
11559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11560 }
11561 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11562 arg2 = obj1;
11563 arg3 = obj2;
11564 if (obj3) {
11565 ecode4 = SWIG_AsVal_int(obj3, &val4);
11566 if (!SWIG_IsOK(ecode4)) {
11567 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
11568 }
11569 arg4 = static_cast< int >(val4);
11570 }
11571 {
11572 PyThreadState* __tstate = wxPyBeginAllowThreads();
11573 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
11574 wxPyEndAllowThreads(__tstate);
11575 if (PyErr_Occurred()) SWIG_fail;
11576 }
11577 resultobj = SWIG_Py_Void();
11578 return resultobj;
11579 fail:
11580 return NULL;
11581 }
11582
11583
11584 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11585 PyObject *resultobj = 0;
11586 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11587 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
11588 int arg3 = (int) wxID_ANY ;
11589 void *argp1 = 0 ;
11590 int res1 = 0 ;
11591 void *argp2 = 0 ;
11592 int res2 = 0 ;
11593 int val3 ;
11594 int ecode3 = 0 ;
11595 PyObject * obj0 = 0 ;
11596 PyObject * obj1 = 0 ;
11597 PyObject * obj2 = 0 ;
11598 char * kwnames[] = {
11599 (char *) "self",(char *) "owner",(char *) "id", NULL
11600 };
11601
11602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11604 if (!SWIG_IsOK(res1)) {
11605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11606 }
11607 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
11609 if (!SWIG_IsOK(res2)) {
11610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
11611 }
11612 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
11613 if (obj2) {
11614 ecode3 = SWIG_AsVal_int(obj2, &val3);
11615 if (!SWIG_IsOK(ecode3)) {
11616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
11617 }
11618 arg3 = static_cast< int >(val3);
11619 }
11620 {
11621 PyThreadState* __tstate = wxPyBeginAllowThreads();
11622 (arg1)->SetOwner(arg2,arg3);
11623 wxPyEndAllowThreads(__tstate);
11624 if (PyErr_Occurred()) SWIG_fail;
11625 }
11626 resultobj = SWIG_Py_Void();
11627 return resultobj;
11628 fail:
11629 return NULL;
11630 }
11631
11632
11633 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11634 PyObject *resultobj = 0;
11635 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11636 wxEvtHandler *result = 0 ;
11637 void *argp1 = 0 ;
11638 int res1 = 0 ;
11639 PyObject *swig_obj[1] ;
11640
11641 if (!args) SWIG_fail;
11642 swig_obj[0] = args;
11643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11644 if (!SWIG_IsOK(res1)) {
11645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11646 }
11647 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11648 {
11649 PyThreadState* __tstate = wxPyBeginAllowThreads();
11650 result = (wxEvtHandler *)(arg1)->GetOwner();
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 {
11655 resultobj = wxPyMake_wxObject(result, 0);
11656 }
11657 return resultobj;
11658 fail:
11659 return NULL;
11660 }
11661
11662
11663 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11664 PyObject *resultobj = 0;
11665 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11666 int arg2 = (int) -1 ;
11667 bool arg3 = (bool) false ;
11668 bool result;
11669 void *argp1 = 0 ;
11670 int res1 = 0 ;
11671 int val2 ;
11672 int ecode2 = 0 ;
11673 bool val3 ;
11674 int ecode3 = 0 ;
11675 PyObject * obj0 = 0 ;
11676 PyObject * obj1 = 0 ;
11677 PyObject * obj2 = 0 ;
11678 char * kwnames[] = {
11679 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
11680 };
11681
11682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11684 if (!SWIG_IsOK(res1)) {
11685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11686 }
11687 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11688 if (obj1) {
11689 ecode2 = SWIG_AsVal_int(obj1, &val2);
11690 if (!SWIG_IsOK(ecode2)) {
11691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
11692 }
11693 arg2 = static_cast< int >(val2);
11694 }
11695 if (obj2) {
11696 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11697 if (!SWIG_IsOK(ecode3)) {
11698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
11699 }
11700 arg3 = static_cast< bool >(val3);
11701 }
11702 {
11703 PyThreadState* __tstate = wxPyBeginAllowThreads();
11704 result = (bool)(arg1)->Start(arg2,arg3);
11705 wxPyEndAllowThreads(__tstate);
11706 if (PyErr_Occurred()) SWIG_fail;
11707 }
11708 {
11709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11710 }
11711 return resultobj;
11712 fail:
11713 return NULL;
11714 }
11715
11716
11717 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11718 PyObject *resultobj = 0;
11719 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11720 void *argp1 = 0 ;
11721 int res1 = 0 ;
11722 PyObject *swig_obj[1] ;
11723
11724 if (!args) SWIG_fail;
11725 swig_obj[0] = args;
11726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11727 if (!SWIG_IsOK(res1)) {
11728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11729 }
11730 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 (arg1)->Stop();
11734 wxPyEndAllowThreads(__tstate);
11735 if (PyErr_Occurred()) SWIG_fail;
11736 }
11737 resultobj = SWIG_Py_Void();
11738 return resultobj;
11739 fail:
11740 return NULL;
11741 }
11742
11743
11744 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11745 PyObject *resultobj = 0;
11746 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11747 void *argp1 = 0 ;
11748 int res1 = 0 ;
11749 PyObject *swig_obj[1] ;
11750
11751 if (!args) SWIG_fail;
11752 swig_obj[0] = args;
11753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11754 if (!SWIG_IsOK(res1)) {
11755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
11756 }
11757 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11758 {
11759 PyThreadState* __tstate = wxPyBeginAllowThreads();
11760 (arg1)->Notify();
11761 wxPyEndAllowThreads(__tstate);
11762 if (PyErr_Occurred()) SWIG_fail;
11763 }
11764 resultobj = SWIG_Py_Void();
11765 return resultobj;
11766 fail:
11767 return NULL;
11768 }
11769
11770
11771 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11772 PyObject *resultobj = 0;
11773 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11774 bool result;
11775 void *argp1 = 0 ;
11776 int res1 = 0 ;
11777 PyObject *swig_obj[1] ;
11778
11779 if (!args) SWIG_fail;
11780 swig_obj[0] = args;
11781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11782 if (!SWIG_IsOK(res1)) {
11783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11784 }
11785 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11786 {
11787 PyThreadState* __tstate = wxPyBeginAllowThreads();
11788 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
11789 wxPyEndAllowThreads(__tstate);
11790 if (PyErr_Occurred()) SWIG_fail;
11791 }
11792 {
11793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11794 }
11795 return resultobj;
11796 fail:
11797 return NULL;
11798 }
11799
11800
11801 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11802 PyObject *resultobj = 0;
11803 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11804 int result;
11805 void *argp1 = 0 ;
11806 int res1 = 0 ;
11807 PyObject *swig_obj[1] ;
11808
11809 if (!args) SWIG_fail;
11810 swig_obj[0] = args;
11811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11812 if (!SWIG_IsOK(res1)) {
11813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11814 }
11815 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11816 {
11817 PyThreadState* __tstate = wxPyBeginAllowThreads();
11818 result = (int)((wxPyTimer const *)arg1)->GetInterval();
11819 wxPyEndAllowThreads(__tstate);
11820 if (PyErr_Occurred()) SWIG_fail;
11821 }
11822 resultobj = SWIG_From_int(static_cast< int >(result));
11823 return resultobj;
11824 fail:
11825 return NULL;
11826 }
11827
11828
11829 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11830 PyObject *resultobj = 0;
11831 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11832 int result;
11833 void *argp1 = 0 ;
11834 int res1 = 0 ;
11835 PyObject *swig_obj[1] ;
11836
11837 if (!args) SWIG_fail;
11838 swig_obj[0] = args;
11839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11840 if (!SWIG_IsOK(res1)) {
11841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11842 }
11843 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11844 {
11845 PyThreadState* __tstate = wxPyBeginAllowThreads();
11846 result = (int)((wxPyTimer const *)arg1)->GetId();
11847 wxPyEndAllowThreads(__tstate);
11848 if (PyErr_Occurred()) SWIG_fail;
11849 }
11850 resultobj = SWIG_From_int(static_cast< int >(result));
11851 return resultobj;
11852 fail:
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11858 PyObject *resultobj = 0;
11859 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
11860 bool result;
11861 void *argp1 = 0 ;
11862 int res1 = 0 ;
11863 PyObject *swig_obj[1] ;
11864
11865 if (!args) SWIG_fail;
11866 swig_obj[0] = args;
11867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
11868 if (!SWIG_IsOK(res1)) {
11869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
11870 }
11871 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
11872 {
11873 PyThreadState* __tstate = wxPyBeginAllowThreads();
11874 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11880 }
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11888 PyObject *obj;
11889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11890 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
11891 return SWIG_Py_Void();
11892 }
11893
11894 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11895 return SWIG_Python_InitShadowInstance(args);
11896 }
11897
11898 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11899 PyObject *resultobj = 0;
11900 int arg1 = (int) 0 ;
11901 int arg2 = (int) 0 ;
11902 wxTimerEvent *result = 0 ;
11903 int val1 ;
11904 int ecode1 = 0 ;
11905 int val2 ;
11906 int ecode2 = 0 ;
11907 PyObject * obj0 = 0 ;
11908 PyObject * obj1 = 0 ;
11909 char * kwnames[] = {
11910 (char *) "timerid",(char *) "interval", NULL
11911 };
11912
11913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
11914 if (obj0) {
11915 ecode1 = SWIG_AsVal_int(obj0, &val1);
11916 if (!SWIG_IsOK(ecode1)) {
11917 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
11918 }
11919 arg1 = static_cast< int >(val1);
11920 }
11921 if (obj1) {
11922 ecode2 = SWIG_AsVal_int(obj1, &val2);
11923 if (!SWIG_IsOK(ecode2)) {
11924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
11925 }
11926 arg2 = static_cast< int >(val2);
11927 }
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
11935 return resultobj;
11936 fail:
11937 return NULL;
11938 }
11939
11940
11941 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11942 PyObject *resultobj = 0;
11943 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
11944 int result;
11945 void *argp1 = 0 ;
11946 int res1 = 0 ;
11947 PyObject *swig_obj[1] ;
11948
11949 if (!args) SWIG_fail;
11950 swig_obj[0] = args;
11951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
11952 if (!SWIG_IsOK(res1)) {
11953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
11954 }
11955 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
11956 {
11957 PyThreadState* __tstate = wxPyBeginAllowThreads();
11958 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
11959 wxPyEndAllowThreads(__tstate);
11960 if (PyErr_Occurred()) SWIG_fail;
11961 }
11962 resultobj = SWIG_From_int(static_cast< int >(result));
11963 return resultobj;
11964 fail:
11965 return NULL;
11966 }
11967
11968
11969 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11970 PyObject *obj;
11971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11972 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
11973 return SWIG_Py_Void();
11974 }
11975
11976 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11977 return SWIG_Python_InitShadowInstance(args);
11978 }
11979
11980 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11981 PyObject *resultobj = 0;
11982 wxTimer *arg1 = 0 ;
11983 wxTimerRunner *result = 0 ;
11984 void *argp1 = 0 ;
11985 int res1 = 0 ;
11986
11987 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
11988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
11989 if (!SWIG_IsOK(res1)) {
11990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11991 }
11992 if (!argp1) {
11993 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
11994 }
11995 arg1 = reinterpret_cast< wxTimer * >(argp1);
11996 {
11997 if (!wxPyCheckForApp()) SWIG_fail;
11998 PyThreadState* __tstate = wxPyBeginAllowThreads();
11999 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12004 return resultobj;
12005 fail:
12006 return NULL;
12007 }
12008
12009
12010 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12011 PyObject *resultobj = 0;
12012 wxTimer *arg1 = 0 ;
12013 int arg2 ;
12014 bool arg3 = (bool) false ;
12015 wxTimerRunner *result = 0 ;
12016 void *argp1 = 0 ;
12017 int res1 = 0 ;
12018 int val2 ;
12019 int ecode2 = 0 ;
12020 bool val3 ;
12021 int ecode3 = 0 ;
12022
12023 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
12024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
12025 if (!SWIG_IsOK(res1)) {
12026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12027 }
12028 if (!argp1) {
12029 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
12030 }
12031 arg1 = reinterpret_cast< wxTimer * >(argp1);
12032 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
12033 if (!SWIG_IsOK(ecode2)) {
12034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
12035 }
12036 arg2 = static_cast< int >(val2);
12037 if (swig_obj[2]) {
12038 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
12039 if (!SWIG_IsOK(ecode3)) {
12040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
12041 }
12042 arg3 = static_cast< bool >(val3);
12043 }
12044 {
12045 if (!wxPyCheckForApp()) SWIG_fail;
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
12059 int argc;
12060 PyObject *argv[4];
12061
12062 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
12063 --argc;
12064 if (argc == 1) {
12065 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
12066 }
12067 if ((argc >= 2) && (argc <= 3)) {
12068 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
12069 }
12070
12071 fail:
12072 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
12073 return NULL;
12074 }
12075
12076
12077 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12078 PyObject *resultobj = 0;
12079 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12080 void *argp1 = 0 ;
12081 int res1 = 0 ;
12082 PyObject *swig_obj[1] ;
12083
12084 if (!args) SWIG_fail;
12085 swig_obj[0] = args;
12086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
12087 if (!SWIG_IsOK(res1)) {
12088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12089 }
12090 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12091 {
12092 PyThreadState* __tstate = wxPyBeginAllowThreads();
12093 delete arg1;
12094
12095 wxPyEndAllowThreads(__tstate);
12096 if (PyErr_Occurred()) SWIG_fail;
12097 }
12098 resultobj = SWIG_Py_Void();
12099 return resultobj;
12100 fail:
12101 return NULL;
12102 }
12103
12104
12105 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12106 PyObject *resultobj = 0;
12107 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
12108 int arg2 ;
12109 bool arg3 = (bool) false ;
12110 void *argp1 = 0 ;
12111 int res1 = 0 ;
12112 int val2 ;
12113 int ecode2 = 0 ;
12114 bool val3 ;
12115 int ecode3 = 0 ;
12116 PyObject * obj0 = 0 ;
12117 PyObject * obj1 = 0 ;
12118 PyObject * obj2 = 0 ;
12119 char * kwnames[] = {
12120 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
12121 };
12122
12123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
12125 if (!SWIG_IsOK(res1)) {
12126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
12127 }
12128 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
12129 ecode2 = SWIG_AsVal_int(obj1, &val2);
12130 if (!SWIG_IsOK(ecode2)) {
12131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
12132 }
12133 arg2 = static_cast< int >(val2);
12134 if (obj2) {
12135 ecode3 = SWIG_AsVal_bool(obj2, &val3);
12136 if (!SWIG_IsOK(ecode3)) {
12137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
12138 }
12139 arg3 = static_cast< bool >(val3);
12140 }
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 (arg1)->Start(arg2,arg3);
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 resultobj = SWIG_Py_Void();
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12155 PyObject *obj;
12156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12157 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
12158 return SWIG_Py_Void();
12159 }
12160
12161 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12162 return SWIG_Python_InitShadowInstance(args);
12163 }
12164
12165 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12166 PyObject *resultobj = 0;
12167 wxLog *result = 0 ;
12168
12169 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
12170 {
12171 PyThreadState* __tstate = wxPyBeginAllowThreads();
12172 result = (wxLog *)new wxLog();
12173 wxPyEndAllowThreads(__tstate);
12174 if (PyErr_Occurred()) SWIG_fail;
12175 }
12176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12184 PyObject *resultobj = 0;
12185 wxLog *arg1 = (wxLog *) 0 ;
12186 void *argp1 = 0 ;
12187 int res1 = 0 ;
12188 PyObject *swig_obj[1] ;
12189
12190 if (!args) SWIG_fail;
12191 swig_obj[0] = args;
12192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12193 if (!SWIG_IsOK(res1)) {
12194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
12195 }
12196 arg1 = reinterpret_cast< wxLog * >(argp1);
12197 {
12198 PyThreadState* __tstate = wxPyBeginAllowThreads();
12199 delete arg1;
12200
12201 wxPyEndAllowThreads(__tstate);
12202 if (PyErr_Occurred()) SWIG_fail;
12203 }
12204 resultobj = SWIG_Py_Void();
12205 return resultobj;
12206 fail:
12207 return NULL;
12208 }
12209
12210
12211 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12212 PyObject *resultobj = 0;
12213 bool result;
12214
12215 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
12216 {
12217 PyThreadState* __tstate = wxPyBeginAllowThreads();
12218 result = (bool)wxLog::IsEnabled();
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 {
12223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12224 }
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = 0;
12233 bool arg1 = (bool) true ;
12234 bool result;
12235 bool val1 ;
12236 int ecode1 = 0 ;
12237 PyObject * obj0 = 0 ;
12238 char * kwnames[] = {
12239 (char *) "doIt", NULL
12240 };
12241
12242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
12243 if (obj0) {
12244 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12245 if (!SWIG_IsOK(ecode1)) {
12246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
12247 }
12248 arg1 = static_cast< bool >(val1);
12249 }
12250 {
12251 PyThreadState* __tstate = wxPyBeginAllowThreads();
12252 result = (bool)wxLog::EnableLogging(arg1);
12253 wxPyEndAllowThreads(__tstate);
12254 if (PyErr_Occurred()) SWIG_fail;
12255 }
12256 {
12257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12258 }
12259 return resultobj;
12260 fail:
12261 return NULL;
12262 }
12263
12264
12265 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12266 PyObject *resultobj = 0;
12267 wxLogLevel arg1 ;
12268 wxChar *arg2 = (wxChar *) 0 ;
12269 time_t arg3 ;
12270 unsigned long val1 ;
12271 int ecode1 = 0 ;
12272 void *argp2 = 0 ;
12273 int res2 = 0 ;
12274 unsigned int val3 ;
12275 int ecode3 = 0 ;
12276 PyObject * obj0 = 0 ;
12277 PyObject * obj1 = 0 ;
12278 PyObject * obj2 = 0 ;
12279 char * kwnames[] = {
12280 (char *) "level",(char *) "szString",(char *) "t", NULL
12281 };
12282
12283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12284 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12285 if (!SWIG_IsOK(ecode1)) {
12286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
12287 }
12288 arg1 = static_cast< wxLogLevel >(val1);
12289 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
12290 if (!SWIG_IsOK(res2)) {
12291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
12292 }
12293 arg2 = reinterpret_cast< wxChar * >(argp2);
12294 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
12295 if (!SWIG_IsOK(ecode3)) {
12296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
12297 }
12298 arg3 = static_cast< time_t >(val3);
12299 {
12300 PyThreadState* __tstate = wxPyBeginAllowThreads();
12301 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
12302 wxPyEndAllowThreads(__tstate);
12303 if (PyErr_Occurred()) SWIG_fail;
12304 }
12305 resultobj = SWIG_Py_Void();
12306 return resultobj;
12307 fail:
12308 return NULL;
12309 }
12310
12311
12312 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12313 PyObject *resultobj = 0;
12314 wxLog *arg1 = (wxLog *) 0 ;
12315 void *argp1 = 0 ;
12316 int res1 = 0 ;
12317 PyObject *swig_obj[1] ;
12318
12319 if (!args) SWIG_fail;
12320 swig_obj[0] = args;
12321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12322 if (!SWIG_IsOK(res1)) {
12323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
12324 }
12325 arg1 = reinterpret_cast< wxLog * >(argp1);
12326 {
12327 PyThreadState* __tstate = wxPyBeginAllowThreads();
12328 (arg1)->Flush();
12329 wxPyEndAllowThreads(__tstate);
12330 if (PyErr_Occurred()) SWIG_fail;
12331 }
12332 resultobj = SWIG_Py_Void();
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12340 PyObject *resultobj = 0;
12341
12342 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
12343 {
12344 PyThreadState* __tstate = wxPyBeginAllowThreads();
12345 wxLog::FlushActive();
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_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357 PyObject *resultobj = 0;
12358 wxLog *result = 0 ;
12359
12360 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 result = (wxLog *)wxLog::GetActiveTarget();
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj = 0;
12376 wxLog *arg1 = (wxLog *) 0 ;
12377 wxLog *result = 0 ;
12378 int res1 = 0 ;
12379 PyObject * obj0 = 0 ;
12380 char * kwnames[] = {
12381 (char *) "pLogger", NULL
12382 };
12383
12384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
12385 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
12386 if (!SWIG_IsOK(res1)) {
12387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
12388 }
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (wxLog *)wxLog::SetActiveTarget(arg1);
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12403 PyObject *resultobj = 0;
12404
12405 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 wxLog::Suspend();
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 resultobj = SWIG_Py_Void();
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12420 PyObject *resultobj = 0;
12421
12422 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
12423 {
12424 PyThreadState* __tstate = wxPyBeginAllowThreads();
12425 wxLog::Resume();
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_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12437 PyObject *resultobj = 0;
12438 bool arg1 = (bool) true ;
12439 bool val1 ;
12440 int ecode1 = 0 ;
12441 PyObject * obj0 = 0 ;
12442 char * kwnames[] = {
12443 (char *) "bVerbose", NULL
12444 };
12445
12446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
12447 if (obj0) {
12448 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12449 if (!SWIG_IsOK(ecode1)) {
12450 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
12451 }
12452 arg1 = static_cast< bool >(val1);
12453 }
12454 {
12455 PyThreadState* __tstate = wxPyBeginAllowThreads();
12456 wxLog::SetVerbose(arg1);
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 resultobj = SWIG_Py_Void();
12461 return resultobj;
12462 fail:
12463 return NULL;
12464 }
12465
12466
12467 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12468 PyObject *resultobj = 0;
12469 wxLogLevel arg1 ;
12470 unsigned long val1 ;
12471 int ecode1 = 0 ;
12472 PyObject * obj0 = 0 ;
12473 char * kwnames[] = {
12474 (char *) "logLevel", NULL
12475 };
12476
12477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
12478 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12479 if (!SWIG_IsOK(ecode1)) {
12480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
12481 }
12482 arg1 = static_cast< wxLogLevel >(val1);
12483 {
12484 PyThreadState* __tstate = wxPyBeginAllowThreads();
12485 wxLog::SetLogLevel(arg1);
12486 wxPyEndAllowThreads(__tstate);
12487 if (PyErr_Occurred()) SWIG_fail;
12488 }
12489 resultobj = SWIG_Py_Void();
12490 return resultobj;
12491 fail:
12492 return NULL;
12493 }
12494
12495
12496 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12497 PyObject *resultobj = 0;
12498
12499 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 wxLog::DontCreateOnDemand();
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_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj = 0;
12515 bool arg1 = (bool) true ;
12516 bool val1 ;
12517 int ecode1 = 0 ;
12518 PyObject * obj0 = 0 ;
12519 char * kwnames[] = {
12520 (char *) "bRepetCounting", NULL
12521 };
12522
12523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
12524 if (obj0) {
12525 ecode1 = SWIG_AsVal_bool(obj0, &val1);
12526 if (!SWIG_IsOK(ecode1)) {
12527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
12528 }
12529 arg1 = static_cast< bool >(val1);
12530 }
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 wxLog::SetRepetitionCounting(arg1);
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 resultobj = SWIG_Py_Void();
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12545 PyObject *resultobj = 0;
12546 bool result;
12547
12548 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
12549 {
12550 PyThreadState* __tstate = wxPyBeginAllowThreads();
12551 result = (bool)wxLog::GetRepetitionCounting();
12552 wxPyEndAllowThreads(__tstate);
12553 if (PyErr_Occurred()) SWIG_fail;
12554 }
12555 {
12556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12557 }
12558 return resultobj;
12559 fail:
12560 return NULL;
12561 }
12562
12563
12564 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12565 PyObject *resultobj = 0;
12566 wxTraceMask arg1 ;
12567 unsigned long val1 ;
12568 int ecode1 = 0 ;
12569 PyObject * obj0 = 0 ;
12570 char * kwnames[] = {
12571 (char *) "ulMask", NULL
12572 };
12573
12574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
12575 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12576 if (!SWIG_IsOK(ecode1)) {
12577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
12578 }
12579 arg1 = static_cast< wxTraceMask >(val1);
12580 {
12581 PyThreadState* __tstate = wxPyBeginAllowThreads();
12582 wxLog::SetTraceMask(arg1);
12583 wxPyEndAllowThreads(__tstate);
12584 if (PyErr_Occurred()) SWIG_fail;
12585 }
12586 resultobj = SWIG_Py_Void();
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12594 PyObject *resultobj = 0;
12595 wxString *arg1 = 0 ;
12596 bool temp1 = false ;
12597 PyObject * obj0 = 0 ;
12598 char * kwnames[] = {
12599 (char *) "str", NULL
12600 };
12601
12602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
12603 {
12604 arg1 = wxString_in_helper(obj0);
12605 if (arg1 == NULL) SWIG_fail;
12606 temp1 = true;
12607 }
12608 {
12609 PyThreadState* __tstate = wxPyBeginAllowThreads();
12610 wxLog::AddTraceMask((wxString const &)*arg1);
12611 wxPyEndAllowThreads(__tstate);
12612 if (PyErr_Occurred()) SWIG_fail;
12613 }
12614 resultobj = SWIG_Py_Void();
12615 {
12616 if (temp1)
12617 delete arg1;
12618 }
12619 return resultobj;
12620 fail:
12621 {
12622 if (temp1)
12623 delete arg1;
12624 }
12625 return NULL;
12626 }
12627
12628
12629 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12630 PyObject *resultobj = 0;
12631 wxString *arg1 = 0 ;
12632 bool temp1 = false ;
12633 PyObject * obj0 = 0 ;
12634 char * kwnames[] = {
12635 (char *) "str", NULL
12636 };
12637
12638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
12639 {
12640 arg1 = wxString_in_helper(obj0);
12641 if (arg1 == NULL) SWIG_fail;
12642 temp1 = true;
12643 }
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 wxLog::RemoveTraceMask((wxString const &)*arg1);
12647 wxPyEndAllowThreads(__tstate);
12648 if (PyErr_Occurred()) SWIG_fail;
12649 }
12650 resultobj = SWIG_Py_Void();
12651 {
12652 if (temp1)
12653 delete arg1;
12654 }
12655 return resultobj;
12656 fail:
12657 {
12658 if (temp1)
12659 delete arg1;
12660 }
12661 return NULL;
12662 }
12663
12664
12665 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12666 PyObject *resultobj = 0;
12667
12668 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 wxLog::ClearTraceMasks();
12672 wxPyEndAllowThreads(__tstate);
12673 if (PyErr_Occurred()) SWIG_fail;
12674 }
12675 resultobj = SWIG_Py_Void();
12676 return resultobj;
12677 fail:
12678 return NULL;
12679 }
12680
12681
12682 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12683 PyObject *resultobj = 0;
12684 wxArrayString *result = 0 ;
12685
12686 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 {
12690 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
12691 result = (wxArrayString *) &_result_ref;
12692 }
12693 wxPyEndAllowThreads(__tstate);
12694 if (PyErr_Occurred()) SWIG_fail;
12695 }
12696 {
12697 resultobj = wxArrayString2PyList_helper(*result);
12698 }
12699 return resultobj;
12700 fail:
12701 return NULL;
12702 }
12703
12704
12705 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12706 PyObject *resultobj = 0;
12707 wxChar *arg1 = (wxChar *) 0 ;
12708 void *argp1 = 0 ;
12709 int res1 = 0 ;
12710 PyObject * obj0 = 0 ;
12711 char * kwnames[] = {
12712 (char *) "ts", NULL
12713 };
12714
12715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
12716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12717 if (!SWIG_IsOK(res1)) {
12718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
12719 }
12720 arg1 = reinterpret_cast< wxChar * >(argp1);
12721 {
12722 PyThreadState* __tstate = wxPyBeginAllowThreads();
12723 wxLog::SetTimestamp((wxChar const *)arg1);
12724 wxPyEndAllowThreads(__tstate);
12725 if (PyErr_Occurred()) SWIG_fail;
12726 }
12727 resultobj = SWIG_Py_Void();
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12735 PyObject *resultobj = 0;
12736 bool result;
12737
12738 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
12739 {
12740 PyThreadState* __tstate = wxPyBeginAllowThreads();
12741 result = (bool)wxLog::GetVerbose();
12742 wxPyEndAllowThreads(__tstate);
12743 if (PyErr_Occurred()) SWIG_fail;
12744 }
12745 {
12746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12747 }
12748 return resultobj;
12749 fail:
12750 return NULL;
12751 }
12752
12753
12754 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12755 PyObject *resultobj = 0;
12756 wxTraceMask result;
12757
12758 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
12759 {
12760 PyThreadState* __tstate = wxPyBeginAllowThreads();
12761 result = (wxTraceMask)wxLog::GetTraceMask();
12762 wxPyEndAllowThreads(__tstate);
12763 if (PyErr_Occurred()) SWIG_fail;
12764 }
12765 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12773 PyObject *resultobj = 0;
12774 wxChar *arg1 = (wxChar *) 0 ;
12775 bool result;
12776 void *argp1 = 0 ;
12777 int res1 = 0 ;
12778 PyObject * obj0 = 0 ;
12779 char * kwnames[] = {
12780 (char *) "mask", NULL
12781 };
12782
12783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
12784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
12785 if (!SWIG_IsOK(res1)) {
12786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
12787 }
12788 arg1 = reinterpret_cast< wxChar * >(argp1);
12789 {
12790 PyThreadState* __tstate = wxPyBeginAllowThreads();
12791 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
12792 wxPyEndAllowThreads(__tstate);
12793 if (PyErr_Occurred()) SWIG_fail;
12794 }
12795 {
12796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12797 }
12798 return resultobj;
12799 fail:
12800 return NULL;
12801 }
12802
12803
12804 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12805 PyObject *resultobj = 0;
12806 wxLogLevel result;
12807
12808 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = (wxLogLevel)wxLog::GetLogLevel();
12812 wxPyEndAllowThreads(__tstate);
12813 if (PyErr_Occurred()) SWIG_fail;
12814 }
12815 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12816 return resultobj;
12817 fail:
12818 return NULL;
12819 }
12820
12821
12822 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12823 PyObject *resultobj = 0;
12824 wxChar *result = 0 ;
12825
12826 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 result = (wxChar *)wxLog::GetTimestamp();
12830 wxPyEndAllowThreads(__tstate);
12831 if (PyErr_Occurred()) SWIG_fail;
12832 }
12833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
12834 return resultobj;
12835 fail:
12836 return NULL;
12837 }
12838
12839
12840 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12841 PyObject *resultobj = 0;
12842 wxString result;
12843
12844 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
12845 {
12846 PyThreadState* __tstate = wxPyBeginAllowThreads();
12847 result = wxLog_TimeStamp();
12848 wxPyEndAllowThreads(__tstate);
12849 if (PyErr_Occurred()) SWIG_fail;
12850 }
12851 {
12852 #if wxUSE_UNICODE
12853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12854 #else
12855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12856 #endif
12857 }
12858 return resultobj;
12859 fail:
12860 return NULL;
12861 }
12862
12863
12864 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12865 PyObject *resultobj = 0;
12866 wxLog *arg1 = (wxLog *) 0 ;
12867 void *argp1 = 0 ;
12868 int res1 = 0 ;
12869 PyObject *swig_obj[1] ;
12870
12871 if (!args) SWIG_fail;
12872 swig_obj[0] = args;
12873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12874 if (!SWIG_IsOK(res1)) {
12875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
12876 }
12877 arg1 = reinterpret_cast< wxLog * >(argp1);
12878 {
12879 PyThreadState* __tstate = wxPyBeginAllowThreads();
12880 wxLog_Destroy(arg1);
12881 wxPyEndAllowThreads(__tstate);
12882 if (PyErr_Occurred()) SWIG_fail;
12883 }
12884 resultobj = SWIG_Py_Void();
12885 return resultobj;
12886 fail:
12887 return NULL;
12888 }
12889
12890
12891 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12892 PyObject *obj;
12893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12894 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
12895 return SWIG_Py_Void();
12896 }
12897
12898 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12899 return SWIG_Python_InitShadowInstance(args);
12900 }
12901
12902 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903 PyObject *resultobj = 0;
12904 wxLogStderr *result = 0 ;
12905
12906 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
12907 {
12908 PyThreadState* __tstate = wxPyBeginAllowThreads();
12909 result = (wxLogStderr *)new wxLogStderr();
12910 wxPyEndAllowThreads(__tstate);
12911 if (PyErr_Occurred()) SWIG_fail;
12912 }
12913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
12914 return resultobj;
12915 fail:
12916 return NULL;
12917 }
12918
12919
12920 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12921 PyObject *obj;
12922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12923 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
12924 return SWIG_Py_Void();
12925 }
12926
12927 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12928 return SWIG_Python_InitShadowInstance(args);
12929 }
12930
12931 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12932 PyObject *resultobj = 0;
12933 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
12934 wxLogTextCtrl *result = 0 ;
12935 void *argp1 = 0 ;
12936 int res1 = 0 ;
12937 PyObject * obj0 = 0 ;
12938 char * kwnames[] = {
12939 (char *) "pTextCtrl", NULL
12940 };
12941
12942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
12943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
12944 if (!SWIG_IsOK(res1)) {
12945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
12946 }
12947 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
12948 {
12949 PyThreadState* __tstate = wxPyBeginAllowThreads();
12950 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
12951 wxPyEndAllowThreads(__tstate);
12952 if (PyErr_Occurred()) SWIG_fail;
12953 }
12954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
12955 return resultobj;
12956 fail:
12957 return NULL;
12958 }
12959
12960
12961 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12962 PyObject *obj;
12963 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12964 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
12965 return SWIG_Py_Void();
12966 }
12967
12968 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12969 return SWIG_Python_InitShadowInstance(args);
12970 }
12971
12972 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12973 PyObject *resultobj = 0;
12974 wxLogGui *result = 0 ;
12975
12976 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (wxLogGui *)new wxLogGui();
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12991 PyObject *obj;
12992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12993 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
12994 return SWIG_Py_Void();
12995 }
12996
12997 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12998 return SWIG_Python_InitShadowInstance(args);
12999 }
13000
13001 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13002 PyObject *resultobj = 0;
13003 wxFrame *arg1 = (wxFrame *) 0 ;
13004 wxString *arg2 = 0 ;
13005 bool arg3 = (bool) true ;
13006 bool arg4 = (bool) true ;
13007 wxLogWindow *result = 0 ;
13008 void *argp1 = 0 ;
13009 int res1 = 0 ;
13010 bool temp2 = false ;
13011 bool val3 ;
13012 int ecode3 = 0 ;
13013 bool val4 ;
13014 int ecode4 = 0 ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 PyObject * obj2 = 0 ;
13018 PyObject * obj3 = 0 ;
13019 char * kwnames[] = {
13020 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
13021 };
13022
13023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13025 if (!SWIG_IsOK(res1)) {
13026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
13027 }
13028 arg1 = reinterpret_cast< wxFrame * >(argp1);
13029 {
13030 arg2 = wxString_in_helper(obj1);
13031 if (arg2 == NULL) SWIG_fail;
13032 temp2 = true;
13033 }
13034 if (obj2) {
13035 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13036 if (!SWIG_IsOK(ecode3)) {
13037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
13038 }
13039 arg3 = static_cast< bool >(val3);
13040 }
13041 if (obj3) {
13042 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13043 if (!SWIG_IsOK(ecode4)) {
13044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
13045 }
13046 arg4 = static_cast< bool >(val4);
13047 }
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
13051 wxPyEndAllowThreads(__tstate);
13052 if (PyErr_Occurred()) SWIG_fail;
13053 }
13054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
13055 {
13056 if (temp2)
13057 delete arg2;
13058 }
13059 return resultobj;
13060 fail:
13061 {
13062 if (temp2)
13063 delete arg2;
13064 }
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13070 PyObject *resultobj = 0;
13071 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13072 bool arg2 = (bool) true ;
13073 void *argp1 = 0 ;
13074 int res1 = 0 ;
13075 bool val2 ;
13076 int ecode2 = 0 ;
13077 PyObject * obj0 = 0 ;
13078 PyObject * obj1 = 0 ;
13079 char * kwnames[] = {
13080 (char *) "self",(char *) "bShow", NULL
13081 };
13082
13083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
13084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13085 if (!SWIG_IsOK(res1)) {
13086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13087 }
13088 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13089 if (obj1) {
13090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13091 if (!SWIG_IsOK(ecode2)) {
13092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
13093 }
13094 arg2 = static_cast< bool >(val2);
13095 }
13096 {
13097 PyThreadState* __tstate = wxPyBeginAllowThreads();
13098 (arg1)->Show(arg2);
13099 wxPyEndAllowThreads(__tstate);
13100 if (PyErr_Occurred()) SWIG_fail;
13101 }
13102 resultobj = SWIG_Py_Void();
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13110 PyObject *resultobj = 0;
13111 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13112 wxFrame *result = 0 ;
13113 void *argp1 = 0 ;
13114 int res1 = 0 ;
13115 PyObject *swig_obj[1] ;
13116
13117 if (!args) SWIG_fail;
13118 swig_obj[0] = args;
13119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13120 if (!SWIG_IsOK(res1)) {
13121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13122 }
13123 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13124 {
13125 PyThreadState* __tstate = wxPyBeginAllowThreads();
13126 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
13127 wxPyEndAllowThreads(__tstate);
13128 if (PyErr_Occurred()) SWIG_fail;
13129 }
13130 {
13131 resultobj = wxPyMake_wxObject(result, (bool)0);
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13140 PyObject *resultobj = 0;
13141 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13142 wxLog *result = 0 ;
13143 void *argp1 = 0 ;
13144 int res1 = 0 ;
13145 PyObject *swig_obj[1] ;
13146
13147 if (!args) SWIG_fail;
13148 swig_obj[0] = args;
13149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13150 if (!SWIG_IsOK(res1)) {
13151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13152 }
13153 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13154 {
13155 PyThreadState* __tstate = wxPyBeginAllowThreads();
13156 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13168 PyObject *resultobj = 0;
13169 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13170 bool result;
13171 void *argp1 = 0 ;
13172 int res1 = 0 ;
13173 PyObject *swig_obj[1] ;
13174
13175 if (!args) SWIG_fail;
13176 swig_obj[0] = args;
13177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13178 if (!SWIG_IsOK(res1)) {
13179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
13180 }
13181 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13182 {
13183 PyThreadState* __tstate = wxPyBeginAllowThreads();
13184 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 {
13189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13190 }
13191 return resultobj;
13192 fail:
13193 return NULL;
13194 }
13195
13196
13197 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13198 PyObject *resultobj = 0;
13199 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
13200 bool arg2 ;
13201 void *argp1 = 0 ;
13202 int res1 = 0 ;
13203 bool val2 ;
13204 int ecode2 = 0 ;
13205 PyObject * obj0 = 0 ;
13206 PyObject * obj1 = 0 ;
13207 char * kwnames[] = {
13208 (char *) "self",(char *) "bDoPass", NULL
13209 };
13210
13211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
13213 if (!SWIG_IsOK(res1)) {
13214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
13215 }
13216 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
13217 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13218 if (!SWIG_IsOK(ecode2)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13220 }
13221 arg2 = static_cast< bool >(val2);
13222 {
13223 PyThreadState* __tstate = wxPyBeginAllowThreads();
13224 (arg1)->PassMessages(arg2);
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 resultobj = SWIG_Py_Void();
13229 return resultobj;
13230 fail:
13231 return NULL;
13232 }
13233
13234
13235 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13236 PyObject *obj;
13237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13238 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
13239 return SWIG_Py_Void();
13240 }
13241
13242 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13243 return SWIG_Python_InitShadowInstance(args);
13244 }
13245
13246 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13247 PyObject *resultobj = 0;
13248 wxLog *arg1 = (wxLog *) 0 ;
13249 wxLogChain *result = 0 ;
13250 void *argp1 = 0 ;
13251 int res1 = 0 ;
13252 PyObject * obj0 = 0 ;
13253 char * kwnames[] = {
13254 (char *) "logger", NULL
13255 };
13256
13257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
13258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
13259 if (!SWIG_IsOK(res1)) {
13260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
13261 }
13262 arg1 = reinterpret_cast< wxLog * >(argp1);
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 result = (wxLogChain *)new wxLogChain(arg1);
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13277 PyObject *resultobj = 0;
13278 wxLogChain *arg1 = (wxLogChain *) 0 ;
13279 wxLog *arg2 = (wxLog *) 0 ;
13280 void *argp1 = 0 ;
13281 int res1 = 0 ;
13282 void *argp2 = 0 ;
13283 int res2 = 0 ;
13284 PyObject * obj0 = 0 ;
13285 PyObject * obj1 = 0 ;
13286 char * kwnames[] = {
13287 (char *) "self",(char *) "logger", NULL
13288 };
13289
13290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
13291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13292 if (!SWIG_IsOK(res1)) {
13293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13294 }
13295 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
13297 if (!SWIG_IsOK(res2)) {
13298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
13299 }
13300 arg2 = reinterpret_cast< wxLog * >(argp2);
13301 {
13302 PyThreadState* __tstate = wxPyBeginAllowThreads();
13303 (arg1)->SetLog(arg2);
13304 wxPyEndAllowThreads(__tstate);
13305 if (PyErr_Occurred()) SWIG_fail;
13306 }
13307 resultobj = SWIG_Py_Void();
13308 return resultobj;
13309 fail:
13310 return NULL;
13311 }
13312
13313
13314 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj = 0;
13316 wxLogChain *arg1 = (wxLogChain *) 0 ;
13317 bool arg2 ;
13318 void *argp1 = 0 ;
13319 int res1 = 0 ;
13320 bool val2 ;
13321 int ecode2 = 0 ;
13322 PyObject * obj0 = 0 ;
13323 PyObject * obj1 = 0 ;
13324 char * kwnames[] = {
13325 (char *) "self",(char *) "bDoPass", NULL
13326 };
13327
13328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
13329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13330 if (!SWIG_IsOK(res1)) {
13331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13332 }
13333 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13334 ecode2 = SWIG_AsVal_bool(obj1, &val2);
13335 if (!SWIG_IsOK(ecode2)) {
13336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
13337 }
13338 arg2 = static_cast< bool >(val2);
13339 {
13340 PyThreadState* __tstate = wxPyBeginAllowThreads();
13341 (arg1)->PassMessages(arg2);
13342 wxPyEndAllowThreads(__tstate);
13343 if (PyErr_Occurred()) SWIG_fail;
13344 }
13345 resultobj = SWIG_Py_Void();
13346 return resultobj;
13347 fail:
13348 return NULL;
13349 }
13350
13351
13352 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13353 PyObject *resultobj = 0;
13354 wxLogChain *arg1 = (wxLogChain *) 0 ;
13355 bool result;
13356 void *argp1 = 0 ;
13357 int res1 = 0 ;
13358 PyObject *swig_obj[1] ;
13359
13360 if (!args) SWIG_fail;
13361 swig_obj[0] = args;
13362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13363 if (!SWIG_IsOK(res1)) {
13364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
13365 }
13366 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 result = (bool)(arg1)->IsPassingMessages();
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 {
13374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13375 }
13376 return resultobj;
13377 fail:
13378 return NULL;
13379 }
13380
13381
13382 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13383 PyObject *resultobj = 0;
13384 wxLogChain *arg1 = (wxLogChain *) 0 ;
13385 wxLog *result = 0 ;
13386 void *argp1 = 0 ;
13387 int res1 = 0 ;
13388 PyObject *swig_obj[1] ;
13389
13390 if (!args) SWIG_fail;
13391 swig_obj[0] = args;
13392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
13393 if (!SWIG_IsOK(res1)) {
13394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
13395 }
13396 arg1 = reinterpret_cast< wxLogChain * >(argp1);
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 result = (wxLog *)(arg1)->GetOldLog();
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13411 PyObject *obj;
13412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13413 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
13414 return SWIG_Py_Void();
13415 }
13416
13417 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13418 return SWIG_Python_InitShadowInstance(args);
13419 }
13420
13421 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13422 PyObject *resultobj = 0;
13423 wxLogBuffer *result = 0 ;
13424
13425 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = (wxLogBuffer *)new wxLogBuffer();
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
13433 return resultobj;
13434 fail:
13435 return NULL;
13436 }
13437
13438
13439 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13440 PyObject *resultobj = 0;
13441 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
13442 wxString *result = 0 ;
13443 void *argp1 = 0 ;
13444 int res1 = 0 ;
13445 PyObject *swig_obj[1] ;
13446
13447 if (!args) SWIG_fail;
13448 swig_obj[0] = args;
13449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
13450 if (!SWIG_IsOK(res1)) {
13451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
13452 }
13453 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
13454 {
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 {
13457 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
13458 result = (wxString *) &_result_ref;
13459 }
13460 wxPyEndAllowThreads(__tstate);
13461 if (PyErr_Occurred()) SWIG_fail;
13462 }
13463 {
13464 #if wxUSE_UNICODE
13465 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13466 #else
13467 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13468 #endif
13469 }
13470 return resultobj;
13471 fail:
13472 return NULL;
13473 }
13474
13475
13476 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13477 PyObject *obj;
13478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13479 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
13480 return SWIG_Py_Void();
13481 }
13482
13483 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13484 return SWIG_Python_InitShadowInstance(args);
13485 }
13486
13487 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13488 PyObject *resultobj = 0;
13489 unsigned long result;
13490
13491 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
13492 {
13493 PyThreadState* __tstate = wxPyBeginAllowThreads();
13494 result = (unsigned long)wxSysErrorCode();
13495 wxPyEndAllowThreads(__tstate);
13496 if (PyErr_Occurred()) SWIG_fail;
13497 }
13498 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
13499 return resultobj;
13500 fail:
13501 return NULL;
13502 }
13503
13504
13505 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13506 PyObject *resultobj = 0;
13507 unsigned long arg1 = (unsigned long) 0 ;
13508 wxString result;
13509 unsigned long val1 ;
13510 int ecode1 = 0 ;
13511 PyObject * obj0 = 0 ;
13512 char * kwnames[] = {
13513 (char *) "nErrCode", NULL
13514 };
13515
13516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
13517 if (obj0) {
13518 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13519 if (!SWIG_IsOK(ecode1)) {
13520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
13521 }
13522 arg1 = static_cast< unsigned long >(val1);
13523 }
13524 {
13525 PyThreadState* __tstate = wxPyBeginAllowThreads();
13526 result = wxSysErrorMsg(arg1);
13527 wxPyEndAllowThreads(__tstate);
13528 if (PyErr_Occurred()) SWIG_fail;
13529 }
13530 {
13531 #if wxUSE_UNICODE
13532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13533 #else
13534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13535 #endif
13536 }
13537 return resultobj;
13538 fail:
13539 return NULL;
13540 }
13541
13542
13543 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13544 PyObject *resultobj = 0;
13545 wxString *arg1 = 0 ;
13546 bool temp1 = false ;
13547 PyObject * obj0 = 0 ;
13548 char * kwnames[] = {
13549 (char *) "msg", NULL
13550 };
13551
13552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
13553 {
13554 arg1 = wxString_in_helper(obj0);
13555 if (arg1 == NULL) SWIG_fail;
13556 temp1 = true;
13557 }
13558 {
13559 PyThreadState* __tstate = wxPyBeginAllowThreads();
13560 wxPyLogFatalError((wxString const &)*arg1);
13561 wxPyEndAllowThreads(__tstate);
13562 if (PyErr_Occurred()) SWIG_fail;
13563 }
13564 resultobj = SWIG_Py_Void();
13565 {
13566 if (temp1)
13567 delete arg1;
13568 }
13569 return resultobj;
13570 fail:
13571 {
13572 if (temp1)
13573 delete arg1;
13574 }
13575 return NULL;
13576 }
13577
13578
13579 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13580 PyObject *resultobj = 0;
13581 wxString *arg1 = 0 ;
13582 bool temp1 = false ;
13583 PyObject * obj0 = 0 ;
13584 char * kwnames[] = {
13585 (char *) "msg", NULL
13586 };
13587
13588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
13589 {
13590 arg1 = wxString_in_helper(obj0);
13591 if (arg1 == NULL) SWIG_fail;
13592 temp1 = true;
13593 }
13594 {
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 wxPyLogError((wxString const &)*arg1);
13597 wxPyEndAllowThreads(__tstate);
13598 if (PyErr_Occurred()) SWIG_fail;
13599 }
13600 resultobj = SWIG_Py_Void();
13601 {
13602 if (temp1)
13603 delete arg1;
13604 }
13605 return resultobj;
13606 fail:
13607 {
13608 if (temp1)
13609 delete arg1;
13610 }
13611 return NULL;
13612 }
13613
13614
13615 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13616 PyObject *resultobj = 0;
13617 wxString *arg1 = 0 ;
13618 bool temp1 = false ;
13619 PyObject * obj0 = 0 ;
13620 char * kwnames[] = {
13621 (char *) "msg", NULL
13622 };
13623
13624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
13625 {
13626 arg1 = wxString_in_helper(obj0);
13627 if (arg1 == NULL) SWIG_fail;
13628 temp1 = true;
13629 }
13630 {
13631 PyThreadState* __tstate = wxPyBeginAllowThreads();
13632 wxPyLogWarning((wxString const &)*arg1);
13633 wxPyEndAllowThreads(__tstate);
13634 if (PyErr_Occurred()) SWIG_fail;
13635 }
13636 resultobj = SWIG_Py_Void();
13637 {
13638 if (temp1)
13639 delete arg1;
13640 }
13641 return resultobj;
13642 fail:
13643 {
13644 if (temp1)
13645 delete arg1;
13646 }
13647 return NULL;
13648 }
13649
13650
13651 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13652 PyObject *resultobj = 0;
13653 wxString *arg1 = 0 ;
13654 bool temp1 = false ;
13655 PyObject * obj0 = 0 ;
13656 char * kwnames[] = {
13657 (char *) "msg", NULL
13658 };
13659
13660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
13661 {
13662 arg1 = wxString_in_helper(obj0);
13663 if (arg1 == NULL) SWIG_fail;
13664 temp1 = true;
13665 }
13666 {
13667 PyThreadState* __tstate = wxPyBeginAllowThreads();
13668 wxPyLogMessage((wxString const &)*arg1);
13669 wxPyEndAllowThreads(__tstate);
13670 if (PyErr_Occurred()) SWIG_fail;
13671 }
13672 resultobj = SWIG_Py_Void();
13673 {
13674 if (temp1)
13675 delete arg1;
13676 }
13677 return resultobj;
13678 fail:
13679 {
13680 if (temp1)
13681 delete arg1;
13682 }
13683 return NULL;
13684 }
13685
13686
13687 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13688 PyObject *resultobj = 0;
13689 wxString *arg1 = 0 ;
13690 bool temp1 = false ;
13691 PyObject * obj0 = 0 ;
13692 char * kwnames[] = {
13693 (char *) "msg", NULL
13694 };
13695
13696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
13697 {
13698 arg1 = wxString_in_helper(obj0);
13699 if (arg1 == NULL) SWIG_fail;
13700 temp1 = true;
13701 }
13702 {
13703 PyThreadState* __tstate = wxPyBeginAllowThreads();
13704 wxPyLogInfo((wxString const &)*arg1);
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 resultobj = SWIG_Py_Void();
13709 {
13710 if (temp1)
13711 delete arg1;
13712 }
13713 return resultobj;
13714 fail:
13715 {
13716 if (temp1)
13717 delete arg1;
13718 }
13719 return NULL;
13720 }
13721
13722
13723 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13724 PyObject *resultobj = 0;
13725 wxString *arg1 = 0 ;
13726 bool temp1 = false ;
13727 PyObject * obj0 = 0 ;
13728 char * kwnames[] = {
13729 (char *) "msg", NULL
13730 };
13731
13732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
13733 {
13734 arg1 = wxString_in_helper(obj0);
13735 if (arg1 == NULL) SWIG_fail;
13736 temp1 = true;
13737 }
13738 {
13739 PyThreadState* __tstate = wxPyBeginAllowThreads();
13740 wxPyLogDebug((wxString const &)*arg1);
13741 wxPyEndAllowThreads(__tstate);
13742 if (PyErr_Occurred()) SWIG_fail;
13743 }
13744 resultobj = SWIG_Py_Void();
13745 {
13746 if (temp1)
13747 delete arg1;
13748 }
13749 return resultobj;
13750 fail:
13751 {
13752 if (temp1)
13753 delete arg1;
13754 }
13755 return NULL;
13756 }
13757
13758
13759 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj = 0;
13761 wxString *arg1 = 0 ;
13762 bool temp1 = false ;
13763 PyObject * obj0 = 0 ;
13764 char * kwnames[] = {
13765 (char *) "msg", NULL
13766 };
13767
13768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
13769 {
13770 arg1 = wxString_in_helper(obj0);
13771 if (arg1 == NULL) SWIG_fail;
13772 temp1 = true;
13773 }
13774 {
13775 PyThreadState* __tstate = wxPyBeginAllowThreads();
13776 wxPyLogVerbose((wxString const &)*arg1);
13777 wxPyEndAllowThreads(__tstate);
13778 if (PyErr_Occurred()) SWIG_fail;
13779 }
13780 resultobj = SWIG_Py_Void();
13781 {
13782 if (temp1)
13783 delete arg1;
13784 }
13785 return resultobj;
13786 fail:
13787 {
13788 if (temp1)
13789 delete arg1;
13790 }
13791 return NULL;
13792 }
13793
13794
13795 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13796 PyObject *resultobj = 0;
13797 wxString *arg1 = 0 ;
13798 bool temp1 = false ;
13799 PyObject * obj0 = 0 ;
13800 char * kwnames[] = {
13801 (char *) "msg", NULL
13802 };
13803
13804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
13805 {
13806 arg1 = wxString_in_helper(obj0);
13807 if (arg1 == NULL) SWIG_fail;
13808 temp1 = true;
13809 }
13810 {
13811 PyThreadState* __tstate = wxPyBeginAllowThreads();
13812 wxPyLogStatus((wxString const &)*arg1);
13813 wxPyEndAllowThreads(__tstate);
13814 if (PyErr_Occurred()) SWIG_fail;
13815 }
13816 resultobj = SWIG_Py_Void();
13817 {
13818 if (temp1)
13819 delete arg1;
13820 }
13821 return resultobj;
13822 fail:
13823 {
13824 if (temp1)
13825 delete arg1;
13826 }
13827 return NULL;
13828 }
13829
13830
13831 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13832 PyObject *resultobj = 0;
13833 wxFrame *arg1 = (wxFrame *) 0 ;
13834 wxString *arg2 = 0 ;
13835 void *argp1 = 0 ;
13836 int res1 = 0 ;
13837 bool temp2 = false ;
13838 PyObject * obj0 = 0 ;
13839 PyObject * obj1 = 0 ;
13840 char * kwnames[] = {
13841 (char *) "pFrame",(char *) "msg", NULL
13842 };
13843
13844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
13845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
13846 if (!SWIG_IsOK(res1)) {
13847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
13848 }
13849 arg1 = reinterpret_cast< wxFrame * >(argp1);
13850 {
13851 arg2 = wxString_in_helper(obj1);
13852 if (arg2 == NULL) SWIG_fail;
13853 temp2 = true;
13854 }
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
13858 wxPyEndAllowThreads(__tstate);
13859 if (PyErr_Occurred()) SWIG_fail;
13860 }
13861 resultobj = SWIG_Py_Void();
13862 {
13863 if (temp2)
13864 delete arg2;
13865 }
13866 return resultobj;
13867 fail:
13868 {
13869 if (temp2)
13870 delete arg2;
13871 }
13872 return NULL;
13873 }
13874
13875
13876 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj = 0;
13878 wxString *arg1 = 0 ;
13879 bool temp1 = false ;
13880 PyObject * obj0 = 0 ;
13881 char * kwnames[] = {
13882 (char *) "msg", NULL
13883 };
13884
13885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
13886 {
13887 arg1 = wxString_in_helper(obj0);
13888 if (arg1 == NULL) SWIG_fail;
13889 temp1 = true;
13890 }
13891 {
13892 PyThreadState* __tstate = wxPyBeginAllowThreads();
13893 wxPyLogSysError((wxString const &)*arg1);
13894 wxPyEndAllowThreads(__tstate);
13895 if (PyErr_Occurred()) SWIG_fail;
13896 }
13897 resultobj = SWIG_Py_Void();
13898 {
13899 if (temp1)
13900 delete arg1;
13901 }
13902 return resultobj;
13903 fail:
13904 {
13905 if (temp1)
13906 delete arg1;
13907 }
13908 return NULL;
13909 }
13910
13911
13912 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13913 PyObject *resultobj = 0;
13914 unsigned long arg1 ;
13915 wxString *arg2 = 0 ;
13916 unsigned long val1 ;
13917 int ecode1 = 0 ;
13918 bool temp2 = false ;
13919 PyObject * obj0 = 0 ;
13920 PyObject * obj1 = 0 ;
13921 char * kwnames[] = {
13922 (char *) "level",(char *) "msg", NULL
13923 };
13924
13925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
13926 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
13927 if (!SWIG_IsOK(ecode1)) {
13928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
13929 }
13930 arg1 = static_cast< unsigned long >(val1);
13931 {
13932 arg2 = wxString_in_helper(obj1);
13933 if (arg2 == NULL) SWIG_fail;
13934 temp2 = true;
13935 }
13936 {
13937 PyThreadState* __tstate = wxPyBeginAllowThreads();
13938 wxPyLogGeneric(arg1,(wxString const &)*arg2);
13939 wxPyEndAllowThreads(__tstate);
13940 if (PyErr_Occurred()) SWIG_fail;
13941 }
13942 resultobj = SWIG_Py_Void();
13943 {
13944 if (temp2)
13945 delete arg2;
13946 }
13947 return resultobj;
13948 fail:
13949 {
13950 if (temp2)
13951 delete arg2;
13952 }
13953 return NULL;
13954 }
13955
13956
13957 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13958 PyObject *resultobj = 0;
13959 unsigned long arg1 ;
13960 wxString *arg2 = 0 ;
13961 unsigned long val1 ;
13962 int ecode1 = 0 ;
13963 bool temp2 = false ;
13964
13965 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
13966 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
13967 if (!SWIG_IsOK(ecode1)) {
13968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
13969 }
13970 arg1 = static_cast< unsigned long >(val1);
13971 {
13972 arg2 = wxString_in_helper(swig_obj[1]);
13973 if (arg2 == NULL) SWIG_fail;
13974 temp2 = true;
13975 }
13976 {
13977 PyThreadState* __tstate = wxPyBeginAllowThreads();
13978 wxPyLogTrace(arg1,(wxString const &)*arg2);
13979 wxPyEndAllowThreads(__tstate);
13980 if (PyErr_Occurred()) SWIG_fail;
13981 }
13982 resultobj = SWIG_Py_Void();
13983 {
13984 if (temp2)
13985 delete arg2;
13986 }
13987 return resultobj;
13988 fail:
13989 {
13990 if (temp2)
13991 delete arg2;
13992 }
13993 return NULL;
13994 }
13995
13996
13997 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
13998 PyObject *resultobj = 0;
13999 wxString *arg1 = 0 ;
14000 wxString *arg2 = 0 ;
14001 bool temp1 = false ;
14002 bool temp2 = false ;
14003
14004 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
14005 {
14006 arg1 = wxString_in_helper(swig_obj[0]);
14007 if (arg1 == NULL) SWIG_fail;
14008 temp1 = true;
14009 }
14010 {
14011 arg2 = wxString_in_helper(swig_obj[1]);
14012 if (arg2 == NULL) SWIG_fail;
14013 temp2 = true;
14014 }
14015 {
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 resultobj = SWIG_Py_Void();
14022 {
14023 if (temp1)
14024 delete arg1;
14025 }
14026 {
14027 if (temp2)
14028 delete arg2;
14029 }
14030 return resultobj;
14031 fail:
14032 {
14033 if (temp1)
14034 delete arg1;
14035 }
14036 {
14037 if (temp2)
14038 delete arg2;
14039 }
14040 return NULL;
14041 }
14042
14043
14044 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
14045 int argc;
14046 PyObject *argv[3];
14047
14048 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
14049 --argc;
14050 if (argc == 2) {
14051 int _v = 0;
14052 {
14053 {
14054 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
14055 }
14056 }
14057 if (!_v) goto check_1;
14058 return _wrap_LogTrace__SWIG_1(self, argc, argv);
14059 }
14060 check_1:
14061
14062 if (argc == 2) {
14063 return _wrap_LogTrace__SWIG_0(self, argc, argv);
14064 }
14065
14066 fail:
14067 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
14068 return NULL;
14069 }
14070
14071
14072 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14073 PyObject *resultobj = 0;
14074 wxString *arg1 = 0 ;
14075 wxString *arg2 = 0 ;
14076 bool temp1 = false ;
14077 bool temp2 = false ;
14078 PyObject * obj0 = 0 ;
14079 PyObject * obj1 = 0 ;
14080 char * kwnames[] = {
14081 (char *) "title",(char *) "text", NULL
14082 };
14083
14084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
14085 {
14086 arg1 = wxString_in_helper(obj0);
14087 if (arg1 == NULL) SWIG_fail;
14088 temp1 = true;
14089 }
14090 {
14091 arg2 = wxString_in_helper(obj1);
14092 if (arg2 == NULL) SWIG_fail;
14093 temp2 = true;
14094 }
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 resultobj = SWIG_Py_Void();
14102 {
14103 if (temp1)
14104 delete arg1;
14105 }
14106 {
14107 if (temp2)
14108 delete arg2;
14109 }
14110 return resultobj;
14111 fail:
14112 {
14113 if (temp1)
14114 delete arg1;
14115 }
14116 {
14117 if (temp2)
14118 delete arg2;
14119 }
14120 return NULL;
14121 }
14122
14123
14124 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14125 PyObject *resultobj = 0;
14126 wxLogNull *result = 0 ;
14127
14128 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 result = (wxLogNull *)new wxLogNull();
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14143 PyObject *resultobj = 0;
14144 wxLogNull *arg1 = (wxLogNull *) 0 ;
14145 void *argp1 = 0 ;
14146 int res1 = 0 ;
14147 PyObject *swig_obj[1] ;
14148
14149 if (!args) SWIG_fail;
14150 swig_obj[0] = args;
14151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
14152 if (!SWIG_IsOK(res1)) {
14153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
14154 }
14155 arg1 = reinterpret_cast< wxLogNull * >(argp1);
14156 {
14157 PyThreadState* __tstate = wxPyBeginAllowThreads();
14158 delete arg1;
14159
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 resultobj = SWIG_Py_Void();
14164 return resultobj;
14165 fail:
14166 return NULL;
14167 }
14168
14169
14170 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14171 PyObject *obj;
14172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14173 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
14174 return SWIG_Py_Void();
14175 }
14176
14177 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14178 return SWIG_Python_InitShadowInstance(args);
14179 }
14180
14181 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14182 PyObject *resultobj = 0;
14183 wxPyLog *result = 0 ;
14184
14185 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
14186 {
14187 PyThreadState* __tstate = wxPyBeginAllowThreads();
14188 result = (wxPyLog *)new wxPyLog();
14189 wxPyEndAllowThreads(__tstate);
14190 if (PyErr_Occurred()) SWIG_fail;
14191 }
14192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
14193 return resultobj;
14194 fail:
14195 return NULL;
14196 }
14197
14198
14199 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14200 PyObject *resultobj = 0;
14201 wxPyLog *arg1 = (wxPyLog *) 0 ;
14202 PyObject *arg2 = (PyObject *) 0 ;
14203 PyObject *arg3 = (PyObject *) 0 ;
14204 void *argp1 = 0 ;
14205 int res1 = 0 ;
14206 PyObject * obj0 = 0 ;
14207 PyObject * obj1 = 0 ;
14208 PyObject * obj2 = 0 ;
14209 char * kwnames[] = {
14210 (char *) "self",(char *) "self",(char *) "_class", NULL
14211 };
14212
14213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
14215 if (!SWIG_IsOK(res1)) {
14216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
14217 }
14218 arg1 = reinterpret_cast< wxPyLog * >(argp1);
14219 arg2 = obj1;
14220 arg3 = obj2;
14221 {
14222 PyThreadState* __tstate = wxPyBeginAllowThreads();
14223 (arg1)->_setCallbackInfo(arg2,arg3);
14224 wxPyEndAllowThreads(__tstate);
14225 if (PyErr_Occurred()) SWIG_fail;
14226 }
14227 resultobj = SWIG_Py_Void();
14228 return resultobj;
14229 fail:
14230 return NULL;
14231 }
14232
14233
14234 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14235 PyObject *obj;
14236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14237 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
14238 return SWIG_Py_Void();
14239 }
14240
14241 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14242 return SWIG_Python_InitShadowInstance(args);
14243 }
14244
14245 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14246 PyObject *resultobj = 0;
14247 int arg1 ;
14248 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14249 int arg3 = (int) wxKILL_NOCHILDREN ;
14250 wxKillError result;
14251 int val1 ;
14252 int ecode1 = 0 ;
14253 int val2 ;
14254 int ecode2 = 0 ;
14255 int val3 ;
14256 int ecode3 = 0 ;
14257 PyObject * obj0 = 0 ;
14258 PyObject * obj1 = 0 ;
14259 PyObject * obj2 = 0 ;
14260 char * kwnames[] = {
14261 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14262 };
14263
14264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14265 ecode1 = SWIG_AsVal_int(obj0, &val1);
14266 if (!SWIG_IsOK(ecode1)) {
14267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
14268 }
14269 arg1 = static_cast< int >(val1);
14270 if (obj1) {
14271 ecode2 = SWIG_AsVal_int(obj1, &val2);
14272 if (!SWIG_IsOK(ecode2)) {
14273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14274 }
14275 arg2 = static_cast< wxSignal >(val2);
14276 }
14277 if (obj2) {
14278 ecode3 = SWIG_AsVal_int(obj2, &val3);
14279 if (!SWIG_IsOK(ecode3)) {
14280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
14281 }
14282 arg3 = static_cast< int >(val3);
14283 }
14284 {
14285 PyThreadState* __tstate = wxPyBeginAllowThreads();
14286 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
14287 wxPyEndAllowThreads(__tstate);
14288 if (PyErr_Occurred()) SWIG_fail;
14289 }
14290 resultobj = SWIG_From_int(static_cast< int >(result));
14291 return resultobj;
14292 fail:
14293 return NULL;
14294 }
14295
14296
14297 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14298 PyObject *resultobj = 0;
14299 int arg1 ;
14300 bool result;
14301 int val1 ;
14302 int ecode1 = 0 ;
14303 PyObject * obj0 = 0 ;
14304 char * kwnames[] = {
14305 (char *) "pid", NULL
14306 };
14307
14308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
14309 ecode1 = SWIG_AsVal_int(obj0, &val1);
14310 if (!SWIG_IsOK(ecode1)) {
14311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
14312 }
14313 arg1 = static_cast< int >(val1);
14314 {
14315 PyThreadState* __tstate = wxPyBeginAllowThreads();
14316 result = (bool)wxPyProcess::Exists(arg1);
14317 wxPyEndAllowThreads(__tstate);
14318 if (PyErr_Occurred()) SWIG_fail;
14319 }
14320 {
14321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14322 }
14323 return resultobj;
14324 fail:
14325 return NULL;
14326 }
14327
14328
14329 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14330 PyObject *resultobj = 0;
14331 wxString *arg1 = 0 ;
14332 int arg2 = (int) wxEXEC_ASYNC ;
14333 wxPyProcess *result = 0 ;
14334 bool temp1 = false ;
14335 int val2 ;
14336 int ecode2 = 0 ;
14337 PyObject * obj0 = 0 ;
14338 PyObject * obj1 = 0 ;
14339 char * kwnames[] = {
14340 (char *) "cmd",(char *) "flags", NULL
14341 };
14342
14343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
14344 {
14345 arg1 = wxString_in_helper(obj0);
14346 if (arg1 == NULL) SWIG_fail;
14347 temp1 = true;
14348 }
14349 if (obj1) {
14350 ecode2 = SWIG_AsVal_int(obj1, &val2);
14351 if (!SWIG_IsOK(ecode2)) {
14352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
14353 }
14354 arg2 = static_cast< int >(val2);
14355 }
14356 {
14357 PyThreadState* __tstate = wxPyBeginAllowThreads();
14358 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
14359 wxPyEndAllowThreads(__tstate);
14360 if (PyErr_Occurred()) SWIG_fail;
14361 }
14362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
14363 {
14364 if (temp1)
14365 delete arg1;
14366 }
14367 return resultobj;
14368 fail:
14369 {
14370 if (temp1)
14371 delete arg1;
14372 }
14373 return NULL;
14374 }
14375
14376
14377 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14378 PyObject *resultobj = 0;
14379 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
14380 int arg2 = (int) -1 ;
14381 wxPyProcess *result = 0 ;
14382 void *argp1 = 0 ;
14383 int res1 = 0 ;
14384 int val2 ;
14385 int ecode2 = 0 ;
14386 PyObject * obj0 = 0 ;
14387 PyObject * obj1 = 0 ;
14388 char * kwnames[] = {
14389 (char *) "parent",(char *) "id", NULL
14390 };
14391
14392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
14393 if (obj0) {
14394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
14395 if (!SWIG_IsOK(res1)) {
14396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
14397 }
14398 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
14399 }
14400 if (obj1) {
14401 ecode2 = SWIG_AsVal_int(obj1, &val2);
14402 if (!SWIG_IsOK(ecode2)) {
14403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
14404 }
14405 arg2 = static_cast< int >(val2);
14406 }
14407 {
14408 PyThreadState* __tstate = wxPyBeginAllowThreads();
14409 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
14410 wxPyEndAllowThreads(__tstate);
14411 if (PyErr_Occurred()) SWIG_fail;
14412 }
14413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
14414 return resultobj;
14415 fail:
14416 return NULL;
14417 }
14418
14419
14420 SWIGINTERN PyObject *_wrap_delete_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14421 PyObject *resultobj = 0;
14422 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14423 void *argp1 = 0 ;
14424 int res1 = 0 ;
14425 PyObject *swig_obj[1] ;
14426
14427 if (!args) SWIG_fail;
14428 swig_obj[0] = args;
14429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, SWIG_POINTER_DISOWN | 0 );
14430 if (!SWIG_IsOK(res1)) {
14431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Process" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14432 }
14433 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14434 {
14435 PyThreadState* __tstate = wxPyBeginAllowThreads();
14436 delete arg1;
14437
14438 wxPyEndAllowThreads(__tstate);
14439 if (PyErr_Occurred()) SWIG_fail;
14440 }
14441 resultobj = SWIG_Py_Void();
14442 return resultobj;
14443 fail:
14444 return NULL;
14445 }
14446
14447
14448 SWIGINTERN PyObject *_wrap_Process_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14449 PyObject *resultobj = 0;
14450 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14451 long result;
14452 void *argp1 = 0 ;
14453 int res1 = 0 ;
14454 PyObject *swig_obj[1] ;
14455
14456 if (!args) SWIG_fail;
14457 swig_obj[0] = args;
14458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14459 if (!SWIG_IsOK(res1)) {
14460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetPid" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14461 }
14462 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14463 {
14464 PyThreadState* __tstate = wxPyBeginAllowThreads();
14465 result = (long)((wxPyProcess const *)arg1)->GetPid();
14466 wxPyEndAllowThreads(__tstate);
14467 if (PyErr_Occurred()) SWIG_fail;
14468 }
14469 resultobj = SWIG_From_long(static_cast< long >(result));
14470 return resultobj;
14471 fail:
14472 return NULL;
14473 }
14474
14475
14476 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj = 0;
14478 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14479 PyObject *arg2 = (PyObject *) 0 ;
14480 PyObject *arg3 = (PyObject *) 0 ;
14481 void *argp1 = 0 ;
14482 int res1 = 0 ;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 PyObject * obj2 = 0 ;
14486 char * kwnames[] = {
14487 (char *) "self",(char *) "self",(char *) "_class", NULL
14488 };
14489
14490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14492 if (!SWIG_IsOK(res1)) {
14493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14494 }
14495 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14496 arg2 = obj1;
14497 arg3 = obj2;
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 (arg1)->_setCallbackInfo(arg2,arg3);
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 resultobj = SWIG_Py_Void();
14505 return resultobj;
14506 fail:
14507 return NULL;
14508 }
14509
14510
14511 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14512 PyObject *resultobj = 0;
14513 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14514 int arg2 ;
14515 int arg3 ;
14516 void *argp1 = 0 ;
14517 int res1 = 0 ;
14518 int val2 ;
14519 int ecode2 = 0 ;
14520 int val3 ;
14521 int ecode3 = 0 ;
14522 PyObject * obj0 = 0 ;
14523 PyObject * obj1 = 0 ;
14524 PyObject * obj2 = 0 ;
14525 char * kwnames[] = {
14526 (char *) "self",(char *) "pid",(char *) "status", NULL
14527 };
14528
14529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14531 if (!SWIG_IsOK(res1)) {
14532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14533 }
14534 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14535 ecode2 = SWIG_AsVal_int(obj1, &val2);
14536 if (!SWIG_IsOK(ecode2)) {
14537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
14538 }
14539 arg2 = static_cast< int >(val2);
14540 ecode3 = SWIG_AsVal_int(obj2, &val3);
14541 if (!SWIG_IsOK(ecode3)) {
14542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
14543 }
14544 arg3 = static_cast< int >(val3);
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 (arg1)->OnTerminate(arg2,arg3);
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 resultobj = SWIG_Py_Void();
14552 return resultobj;
14553 fail:
14554 return NULL;
14555 }
14556
14557
14558 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14559 PyObject *resultobj = 0;
14560 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14561 void *argp1 = 0 ;
14562 int res1 = 0 ;
14563 PyObject *swig_obj[1] ;
14564
14565 if (!args) SWIG_fail;
14566 swig_obj[0] = args;
14567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14568 if (!SWIG_IsOK(res1)) {
14569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14570 }
14571 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14572 {
14573 PyThreadState* __tstate = wxPyBeginAllowThreads();
14574 (arg1)->Redirect();
14575 wxPyEndAllowThreads(__tstate);
14576 if (PyErr_Occurred()) SWIG_fail;
14577 }
14578 resultobj = SWIG_Py_Void();
14579 return resultobj;
14580 fail:
14581 return NULL;
14582 }
14583
14584
14585 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14586 PyObject *resultobj = 0;
14587 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14588 bool result;
14589 void *argp1 = 0 ;
14590 int res1 = 0 ;
14591 PyObject *swig_obj[1] ;
14592
14593 if (!args) SWIG_fail;
14594 swig_obj[0] = args;
14595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14596 if (!SWIG_IsOK(res1)) {
14597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14598 }
14599 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 result = (bool)(arg1)->IsRedirected();
14603 wxPyEndAllowThreads(__tstate);
14604 if (PyErr_Occurred()) SWIG_fail;
14605 }
14606 {
14607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14608 }
14609 return resultobj;
14610 fail:
14611 return NULL;
14612 }
14613
14614
14615 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14616 PyObject *resultobj = 0;
14617 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14618 void *argp1 = 0 ;
14619 int res1 = 0 ;
14620 PyObject *swig_obj[1] ;
14621
14622 if (!args) SWIG_fail;
14623 swig_obj[0] = args;
14624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14625 if (!SWIG_IsOK(res1)) {
14626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14627 }
14628 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 (arg1)->Detach();
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_Py_Void();
14636 return resultobj;
14637 fail:
14638 return NULL;
14639 }
14640
14641
14642 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14643 PyObject *resultobj = 0;
14644 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14645 wxInputStream *result = 0 ;
14646 void *argp1 = 0 ;
14647 int res1 = 0 ;
14648 PyObject *swig_obj[1] ;
14649
14650 if (!args) SWIG_fail;
14651 swig_obj[0] = args;
14652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14653 if (!SWIG_IsOK(res1)) {
14654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14655 }
14656 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (wxInputStream *)(arg1)->GetInputStream();
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 {
14664 wxPyInputStream * _ptr = NULL;
14665
14666 if (result) {
14667 _ptr = new wxPyInputStream(result);
14668 }
14669 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14670 }
14671 return resultobj;
14672 fail:
14673 return NULL;
14674 }
14675
14676
14677 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14678 PyObject *resultobj = 0;
14679 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14680 wxInputStream *result = 0 ;
14681 void *argp1 = 0 ;
14682 int res1 = 0 ;
14683 PyObject *swig_obj[1] ;
14684
14685 if (!args) SWIG_fail;
14686 swig_obj[0] = args;
14687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14690 }
14691 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 result = (wxInputStream *)(arg1)->GetErrorStream();
14695 wxPyEndAllowThreads(__tstate);
14696 if (PyErr_Occurred()) SWIG_fail;
14697 }
14698 {
14699 wxPyInputStream * _ptr = NULL;
14700
14701 if (result) {
14702 _ptr = new wxPyInputStream(result);
14703 }
14704 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
14705 }
14706 return resultobj;
14707 fail:
14708 return NULL;
14709 }
14710
14711
14712 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14713 PyObject *resultobj = 0;
14714 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14715 wxOutputStream *result = 0 ;
14716 void *argp1 = 0 ;
14717 int res1 = 0 ;
14718 PyObject *swig_obj[1] ;
14719
14720 if (!args) SWIG_fail;
14721 swig_obj[0] = args;
14722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14723 if (!SWIG_IsOK(res1)) {
14724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14725 }
14726 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14727 {
14728 PyThreadState* __tstate = wxPyBeginAllowThreads();
14729 result = (wxOutputStream *)(arg1)->GetOutputStream();
14730 wxPyEndAllowThreads(__tstate);
14731 if (PyErr_Occurred()) SWIG_fail;
14732 }
14733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
14734 return resultobj;
14735 fail:
14736 return NULL;
14737 }
14738
14739
14740 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14741 PyObject *resultobj = 0;
14742 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14743 void *argp1 = 0 ;
14744 int res1 = 0 ;
14745 PyObject *swig_obj[1] ;
14746
14747 if (!args) SWIG_fail;
14748 swig_obj[0] = args;
14749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14750 if (!SWIG_IsOK(res1)) {
14751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
14752 }
14753 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14754 {
14755 PyThreadState* __tstate = wxPyBeginAllowThreads();
14756 (arg1)->CloseOutput();
14757 wxPyEndAllowThreads(__tstate);
14758 if (PyErr_Occurred()) SWIG_fail;
14759 }
14760 resultobj = SWIG_Py_Void();
14761 return resultobj;
14762 fail:
14763 return NULL;
14764 }
14765
14766
14767 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14768 PyObject *resultobj = 0;
14769 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14770 bool result;
14771 void *argp1 = 0 ;
14772 int res1 = 0 ;
14773 PyObject *swig_obj[1] ;
14774
14775 if (!args) SWIG_fail;
14776 swig_obj[0] = args;
14777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14778 if (!SWIG_IsOK(res1)) {
14779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14780 }
14781 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
14785 wxPyEndAllowThreads(__tstate);
14786 if (PyErr_Occurred()) SWIG_fail;
14787 }
14788 {
14789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14790 }
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14798 PyObject *resultobj = 0;
14799 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14800 bool result;
14801 void *argp1 = 0 ;
14802 int res1 = 0 ;
14803 PyObject *swig_obj[1] ;
14804
14805 if (!args) SWIG_fail;
14806 swig_obj[0] = args;
14807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14808 if (!SWIG_IsOK(res1)) {
14809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14810 }
14811 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14812 {
14813 PyThreadState* __tstate = wxPyBeginAllowThreads();
14814 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
14815 wxPyEndAllowThreads(__tstate);
14816 if (PyErr_Occurred()) SWIG_fail;
14817 }
14818 {
14819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14820 }
14821 return resultobj;
14822 fail:
14823 return NULL;
14824 }
14825
14826
14827 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14828 PyObject *resultobj = 0;
14829 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
14830 bool result;
14831 void *argp1 = 0 ;
14832 int res1 = 0 ;
14833 PyObject *swig_obj[1] ;
14834
14835 if (!args) SWIG_fail;
14836 swig_obj[0] = args;
14837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14838 if (!SWIG_IsOK(res1)) {
14839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
14840 }
14841 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
14842 {
14843 PyThreadState* __tstate = wxPyBeginAllowThreads();
14844 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
14845 wxPyEndAllowThreads(__tstate);
14846 if (PyErr_Occurred()) SWIG_fail;
14847 }
14848 {
14849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14850 }
14851 return resultobj;
14852 fail:
14853 return NULL;
14854 }
14855
14856
14857 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14858 PyObject *obj;
14859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14860 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
14861 return SWIG_Py_Void();
14862 }
14863
14864 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14865 return SWIG_Python_InitShadowInstance(args);
14866 }
14867
14868 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14869 PyObject *resultobj = 0;
14870 int arg1 = (int) 0 ;
14871 int arg2 = (int) 0 ;
14872 int arg3 = (int) 0 ;
14873 wxProcessEvent *result = 0 ;
14874 int val1 ;
14875 int ecode1 = 0 ;
14876 int val2 ;
14877 int ecode2 = 0 ;
14878 int val3 ;
14879 int ecode3 = 0 ;
14880 PyObject * obj0 = 0 ;
14881 PyObject * obj1 = 0 ;
14882 PyObject * obj2 = 0 ;
14883 char * kwnames[] = {
14884 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
14885 };
14886
14887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14888 if (obj0) {
14889 ecode1 = SWIG_AsVal_int(obj0, &val1);
14890 if (!SWIG_IsOK(ecode1)) {
14891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
14892 }
14893 arg1 = static_cast< int >(val1);
14894 }
14895 if (obj1) {
14896 ecode2 = SWIG_AsVal_int(obj1, &val2);
14897 if (!SWIG_IsOK(ecode2)) {
14898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
14899 }
14900 arg2 = static_cast< int >(val2);
14901 }
14902 if (obj2) {
14903 ecode3 = SWIG_AsVal_int(obj2, &val3);
14904 if (!SWIG_IsOK(ecode3)) {
14905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
14906 }
14907 arg3 = static_cast< int >(val3);
14908 }
14909 {
14910 PyThreadState* __tstate = wxPyBeginAllowThreads();
14911 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
14916 return resultobj;
14917 fail:
14918 return NULL;
14919 }
14920
14921
14922 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14923 PyObject *resultobj = 0;
14924 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14925 int result;
14926 void *argp1 = 0 ;
14927 int res1 = 0 ;
14928 PyObject *swig_obj[1] ;
14929
14930 if (!args) SWIG_fail;
14931 swig_obj[0] = args;
14932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14933 if (!SWIG_IsOK(res1)) {
14934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14935 }
14936 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14937 {
14938 PyThreadState* __tstate = wxPyBeginAllowThreads();
14939 result = (int)(arg1)->GetPid();
14940 wxPyEndAllowThreads(__tstate);
14941 if (PyErr_Occurred()) SWIG_fail;
14942 }
14943 resultobj = SWIG_From_int(static_cast< int >(result));
14944 return resultobj;
14945 fail:
14946 return NULL;
14947 }
14948
14949
14950 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14951 PyObject *resultobj = 0;
14952 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14953 int result;
14954 void *argp1 = 0 ;
14955 int res1 = 0 ;
14956 PyObject *swig_obj[1] ;
14957
14958 if (!args) SWIG_fail;
14959 swig_obj[0] = args;
14960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14961 if (!SWIG_IsOK(res1)) {
14962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14963 }
14964 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14965 {
14966 PyThreadState* __tstate = wxPyBeginAllowThreads();
14967 result = (int)(arg1)->GetExitCode();
14968 wxPyEndAllowThreads(__tstate);
14969 if (PyErr_Occurred()) SWIG_fail;
14970 }
14971 resultobj = SWIG_From_int(static_cast< int >(result));
14972 return resultobj;
14973 fail:
14974 return NULL;
14975 }
14976
14977
14978 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14979 PyObject *resultobj = 0;
14980 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
14981 int arg2 ;
14982 void *argp1 = 0 ;
14983 int res1 = 0 ;
14984 int val2 ;
14985 int ecode2 = 0 ;
14986 PyObject *swig_obj[2] ;
14987
14988 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
14989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
14990 if (!SWIG_IsOK(res1)) {
14991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
14992 }
14993 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
14994 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
14995 if (!SWIG_IsOK(ecode2)) {
14996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
14997 }
14998 arg2 = static_cast< int >(val2);
14999 if (arg1) (arg1)->m_pid = arg2;
15000
15001 resultobj = SWIG_Py_Void();
15002 return resultobj;
15003 fail:
15004 return NULL;
15005 }
15006
15007
15008 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15009 PyObject *resultobj = 0;
15010 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15011 int result;
15012 void *argp1 = 0 ;
15013 int res1 = 0 ;
15014 PyObject *swig_obj[1] ;
15015
15016 if (!args) SWIG_fail;
15017 swig_obj[0] = args;
15018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15019 if (!SWIG_IsOK(res1)) {
15020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15021 }
15022 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15023 result = (int) ((arg1)->m_pid);
15024 resultobj = SWIG_From_int(static_cast< int >(result));
15025 return resultobj;
15026 fail:
15027 return NULL;
15028 }
15029
15030
15031 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15032 PyObject *resultobj = 0;
15033 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15034 int arg2 ;
15035 void *argp1 = 0 ;
15036 int res1 = 0 ;
15037 int val2 ;
15038 int ecode2 = 0 ;
15039 PyObject *swig_obj[2] ;
15040
15041 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
15042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15043 if (!SWIG_IsOK(res1)) {
15044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15045 }
15046 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15047 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
15048 if (!SWIG_IsOK(ecode2)) {
15049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
15050 }
15051 arg2 = static_cast< int >(val2);
15052 if (arg1) (arg1)->m_exitcode = arg2;
15053
15054 resultobj = SWIG_Py_Void();
15055 return resultobj;
15056 fail:
15057 return NULL;
15058 }
15059
15060
15061 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15062 PyObject *resultobj = 0;
15063 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
15064 int result;
15065 void *argp1 = 0 ;
15066 int res1 = 0 ;
15067 PyObject *swig_obj[1] ;
15068
15069 if (!args) SWIG_fail;
15070 swig_obj[0] = args;
15071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
15072 if (!SWIG_IsOK(res1)) {
15073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
15074 }
15075 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
15076 result = (int) ((arg1)->m_exitcode);
15077 resultobj = SWIG_From_int(static_cast< int >(result));
15078 return resultobj;
15079 fail:
15080 return NULL;
15081 }
15082
15083
15084 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15085 PyObject *obj;
15086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15087 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
15088 return SWIG_Py_Void();
15089 }
15090
15091 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15092 return SWIG_Python_InitShadowInstance(args);
15093 }
15094
15095 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15096 PyObject *resultobj = 0;
15097 wxString *arg1 = 0 ;
15098 int arg2 = (int) wxEXEC_ASYNC ;
15099 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
15100 long result;
15101 bool temp1 = false ;
15102 int val2 ;
15103 int ecode2 = 0 ;
15104 void *argp3 = 0 ;
15105 int res3 = 0 ;
15106 PyObject * obj0 = 0 ;
15107 PyObject * obj1 = 0 ;
15108 PyObject * obj2 = 0 ;
15109 char * kwnames[] = {
15110 (char *) "command",(char *) "flags",(char *) "process", NULL
15111 };
15112
15113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15114 {
15115 arg1 = wxString_in_helper(obj0);
15116 if (arg1 == NULL) SWIG_fail;
15117 temp1 = true;
15118 }
15119 if (obj1) {
15120 ecode2 = SWIG_AsVal_int(obj1, &val2);
15121 if (!SWIG_IsOK(ecode2)) {
15122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
15123 }
15124 arg2 = static_cast< int >(val2);
15125 }
15126 if (obj2) {
15127 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
15128 if (!SWIG_IsOK(res3)) {
15129 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
15130 }
15131 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
15132 }
15133 {
15134 if (!wxPyCheckForApp()) SWIG_fail;
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 resultobj = SWIG_From_long(static_cast< long >(result));
15141 {
15142 if (temp1)
15143 delete arg1;
15144 }
15145 return resultobj;
15146 fail:
15147 {
15148 if (temp1)
15149 delete arg1;
15150 }
15151 return NULL;
15152 }
15153
15154
15155 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15156 PyObject *resultobj = 0;
15157 long arg1 ;
15158 wxSignal arg2 = (wxSignal) wxSIGTERM ;
15159 wxKillError *arg3 = (wxKillError *) 0 ;
15160 int arg4 = (int) wxKILL_NOCHILDREN ;
15161 int result;
15162 long val1 ;
15163 int ecode1 = 0 ;
15164 int val2 ;
15165 int ecode2 = 0 ;
15166 wxKillError temp3 ;
15167 int val4 ;
15168 int ecode4 = 0 ;
15169 PyObject * obj0 = 0 ;
15170 PyObject * obj1 = 0 ;
15171 PyObject * obj2 = 0 ;
15172 char * kwnames[] = {
15173 (char *) "pid",(char *) "sig",(char *) "flags", NULL
15174 };
15175
15176 {
15177 arg3 = &temp3;
15178 }
15179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15180 ecode1 = SWIG_AsVal_long(obj0, &val1);
15181 if (!SWIG_IsOK(ecode1)) {
15182 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
15183 }
15184 arg1 = static_cast< long >(val1);
15185 if (obj1) {
15186 ecode2 = SWIG_AsVal_int(obj1, &val2);
15187 if (!SWIG_IsOK(ecode2)) {
15188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
15189 }
15190 arg2 = static_cast< wxSignal >(val2);
15191 }
15192 if (obj2) {
15193 ecode4 = SWIG_AsVal_int(obj2, &val4);
15194 if (!SWIG_IsOK(ecode4)) {
15195 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
15196 }
15197 arg4 = static_cast< int >(val4);
15198 }
15199 {
15200 PyThreadState* __tstate = wxPyBeginAllowThreads();
15201 result = (int)wxKill(arg1,arg2,arg3,arg4);
15202 wxPyEndAllowThreads(__tstate);
15203 if (PyErr_Occurred()) SWIG_fail;
15204 }
15205 resultobj = SWIG_From_int(static_cast< int >(result));
15206 {
15207 PyObject* o;
15208 o = PyInt_FromLong((long) (*arg3));
15209
15210
15211
15212 resultobj = SWIG_Python_AppendOutput(resultobj, o);
15213
15214 }
15215 return resultobj;
15216 fail:
15217 return NULL;
15218 }
15219
15220
15221 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15222 PyObject *resultobj = 0;
15223 int arg1 = (int) wxJOYSTICK1 ;
15224 wxJoystick *result = 0 ;
15225 int val1 ;
15226 int ecode1 = 0 ;
15227 PyObject * obj0 = 0 ;
15228 char * kwnames[] = {
15229 (char *) "joystick", NULL
15230 };
15231
15232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
15233 if (obj0) {
15234 ecode1 = SWIG_AsVal_int(obj0, &val1);
15235 if (!SWIG_IsOK(ecode1)) {
15236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
15237 }
15238 arg1 = static_cast< int >(val1);
15239 }
15240 {
15241 if (!wxPyCheckForApp()) SWIG_fail;
15242 PyThreadState* __tstate = wxPyBeginAllowThreads();
15243 result = (wxJoystick *)new wxJoystick(arg1);
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
15248 return resultobj;
15249 fail:
15250 return NULL;
15251 }
15252
15253
15254 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15255 PyObject *resultobj = 0;
15256 wxJoystick *arg1 = (wxJoystick *) 0 ;
15257 void *argp1 = 0 ;
15258 int res1 = 0 ;
15259 PyObject *swig_obj[1] ;
15260
15261 if (!args) SWIG_fail;
15262 swig_obj[0] = args;
15263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
15264 if (!SWIG_IsOK(res1)) {
15265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
15266 }
15267 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15268 {
15269 PyThreadState* __tstate = wxPyBeginAllowThreads();
15270 delete arg1;
15271
15272 wxPyEndAllowThreads(__tstate);
15273 if (PyErr_Occurred()) SWIG_fail;
15274 }
15275 resultobj = SWIG_Py_Void();
15276 return resultobj;
15277 fail:
15278 return NULL;
15279 }
15280
15281
15282 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15283 PyObject *resultobj = 0;
15284 wxJoystick *arg1 = (wxJoystick *) 0 ;
15285 wxPoint result;
15286 void *argp1 = 0 ;
15287 int res1 = 0 ;
15288 PyObject *swig_obj[1] ;
15289
15290 if (!args) SWIG_fail;
15291 swig_obj[0] = args;
15292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15293 if (!SWIG_IsOK(res1)) {
15294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15295 }
15296 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15297 {
15298 PyThreadState* __tstate = wxPyBeginAllowThreads();
15299 result = (arg1)->GetPosition();
15300 wxPyEndAllowThreads(__tstate);
15301 if (PyErr_Occurred()) SWIG_fail;
15302 }
15303 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15304 return resultobj;
15305 fail:
15306 return NULL;
15307 }
15308
15309
15310 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15311 PyObject *resultobj = 0;
15312 wxJoystick *arg1 = (wxJoystick *) 0 ;
15313 int result;
15314 void *argp1 = 0 ;
15315 int res1 = 0 ;
15316 PyObject *swig_obj[1] ;
15317
15318 if (!args) SWIG_fail;
15319 swig_obj[0] = args;
15320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15321 if (!SWIG_IsOK(res1)) {
15322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15323 }
15324 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15325 {
15326 PyThreadState* __tstate = wxPyBeginAllowThreads();
15327 result = (int)(arg1)->GetZPosition();
15328 wxPyEndAllowThreads(__tstate);
15329 if (PyErr_Occurred()) SWIG_fail;
15330 }
15331 resultobj = SWIG_From_int(static_cast< int >(result));
15332 return resultobj;
15333 fail:
15334 return NULL;
15335 }
15336
15337
15338 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15339 PyObject *resultobj = 0;
15340 wxJoystick *arg1 = (wxJoystick *) 0 ;
15341 int result;
15342 void *argp1 = 0 ;
15343 int res1 = 0 ;
15344 PyObject *swig_obj[1] ;
15345
15346 if (!args) SWIG_fail;
15347 swig_obj[0] = args;
15348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15349 if (!SWIG_IsOK(res1)) {
15350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
15351 }
15352 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15353 {
15354 PyThreadState* __tstate = wxPyBeginAllowThreads();
15355 result = (int)(arg1)->GetButtonState();
15356 wxPyEndAllowThreads(__tstate);
15357 if (PyErr_Occurred()) SWIG_fail;
15358 }
15359 resultobj = SWIG_From_int(static_cast< int >(result));
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15367 PyObject *resultobj = 0;
15368 wxJoystick *arg1 = (wxJoystick *) 0 ;
15369 int result;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 PyObject *swig_obj[1] ;
15373
15374 if (!args) SWIG_fail;
15375 swig_obj[0] = args;
15376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15377 if (!SWIG_IsOK(res1)) {
15378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15379 }
15380 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15381 {
15382 PyThreadState* __tstate = wxPyBeginAllowThreads();
15383 result = (int)(arg1)->GetPOVPosition();
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 resultobj = SWIG_From_int(static_cast< int >(result));
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15395 PyObject *resultobj = 0;
15396 wxJoystick *arg1 = (wxJoystick *) 0 ;
15397 int result;
15398 void *argp1 = 0 ;
15399 int res1 = 0 ;
15400 PyObject *swig_obj[1] ;
15401
15402 if (!args) SWIG_fail;
15403 swig_obj[0] = args;
15404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15405 if (!SWIG_IsOK(res1)) {
15406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15407 }
15408 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15409 {
15410 PyThreadState* __tstate = wxPyBeginAllowThreads();
15411 result = (int)(arg1)->GetPOVCTSPosition();
15412 wxPyEndAllowThreads(__tstate);
15413 if (PyErr_Occurred()) SWIG_fail;
15414 }
15415 resultobj = SWIG_From_int(static_cast< int >(result));
15416 return resultobj;
15417 fail:
15418 return NULL;
15419 }
15420
15421
15422 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15423 PyObject *resultobj = 0;
15424 wxJoystick *arg1 = (wxJoystick *) 0 ;
15425 int result;
15426 void *argp1 = 0 ;
15427 int res1 = 0 ;
15428 PyObject *swig_obj[1] ;
15429
15430 if (!args) SWIG_fail;
15431 swig_obj[0] = args;
15432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15433 if (!SWIG_IsOK(res1)) {
15434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15435 }
15436 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15437 {
15438 PyThreadState* __tstate = wxPyBeginAllowThreads();
15439 result = (int)(arg1)->GetRudderPosition();
15440 wxPyEndAllowThreads(__tstate);
15441 if (PyErr_Occurred()) SWIG_fail;
15442 }
15443 resultobj = SWIG_From_int(static_cast< int >(result));
15444 return resultobj;
15445 fail:
15446 return NULL;
15447 }
15448
15449
15450 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15451 PyObject *resultobj = 0;
15452 wxJoystick *arg1 = (wxJoystick *) 0 ;
15453 int result;
15454 void *argp1 = 0 ;
15455 int res1 = 0 ;
15456 PyObject *swig_obj[1] ;
15457
15458 if (!args) SWIG_fail;
15459 swig_obj[0] = args;
15460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15461 if (!SWIG_IsOK(res1)) {
15462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15463 }
15464 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15465 {
15466 PyThreadState* __tstate = wxPyBeginAllowThreads();
15467 result = (int)(arg1)->GetUPosition();
15468 wxPyEndAllowThreads(__tstate);
15469 if (PyErr_Occurred()) SWIG_fail;
15470 }
15471 resultobj = SWIG_From_int(static_cast< int >(result));
15472 return resultobj;
15473 fail:
15474 return NULL;
15475 }
15476
15477
15478 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15479 PyObject *resultobj = 0;
15480 wxJoystick *arg1 = (wxJoystick *) 0 ;
15481 int result;
15482 void *argp1 = 0 ;
15483 int res1 = 0 ;
15484 PyObject *swig_obj[1] ;
15485
15486 if (!args) SWIG_fail;
15487 swig_obj[0] = args;
15488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15489 if (!SWIG_IsOK(res1)) {
15490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
15491 }
15492 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15493 {
15494 PyThreadState* __tstate = wxPyBeginAllowThreads();
15495 result = (int)(arg1)->GetVPosition();
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 resultobj = SWIG_From_int(static_cast< int >(result));
15500 return resultobj;
15501 fail:
15502 return NULL;
15503 }
15504
15505
15506 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15507 PyObject *resultobj = 0;
15508 wxJoystick *arg1 = (wxJoystick *) 0 ;
15509 int result;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 PyObject *swig_obj[1] ;
15513
15514 if (!args) SWIG_fail;
15515 swig_obj[0] = args;
15516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15517 if (!SWIG_IsOK(res1)) {
15518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15519 }
15520 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15521 {
15522 PyThreadState* __tstate = wxPyBeginAllowThreads();
15523 result = (int)(arg1)->GetMovementThreshold();
15524 wxPyEndAllowThreads(__tstate);
15525 if (PyErr_Occurred()) SWIG_fail;
15526 }
15527 resultobj = SWIG_From_int(static_cast< int >(result));
15528 return resultobj;
15529 fail:
15530 return NULL;
15531 }
15532
15533
15534 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15535 PyObject *resultobj = 0;
15536 wxJoystick *arg1 = (wxJoystick *) 0 ;
15537 int arg2 ;
15538 void *argp1 = 0 ;
15539 int res1 = 0 ;
15540 int val2 ;
15541 int ecode2 = 0 ;
15542 PyObject * obj0 = 0 ;
15543 PyObject * obj1 = 0 ;
15544 char * kwnames[] = {
15545 (char *) "self",(char *) "threshold", NULL
15546 };
15547
15548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
15549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15550 if (!SWIG_IsOK(res1)) {
15551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
15552 }
15553 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15554 ecode2 = SWIG_AsVal_int(obj1, &val2);
15555 if (!SWIG_IsOK(ecode2)) {
15556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
15557 }
15558 arg2 = static_cast< int >(val2);
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 (arg1)->SetMovementThreshold(arg2);
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_Py_Void();
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15573 PyObject *resultobj = 0;
15574 wxJoystick *arg1 = (wxJoystick *) 0 ;
15575 bool result;
15576 void *argp1 = 0 ;
15577 int res1 = 0 ;
15578 PyObject *swig_obj[1] ;
15579
15580 if (!args) SWIG_fail;
15581 swig_obj[0] = args;
15582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15583 if (!SWIG_IsOK(res1)) {
15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
15585 }
15586 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15587 {
15588 PyThreadState* __tstate = wxPyBeginAllowThreads();
15589 result = (bool)(arg1)->IsOk();
15590 wxPyEndAllowThreads(__tstate);
15591 if (PyErr_Occurred()) SWIG_fail;
15592 }
15593 {
15594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15595 }
15596 return resultobj;
15597 fail:
15598 return NULL;
15599 }
15600
15601
15602 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15603 PyObject *resultobj = 0;
15604 wxJoystick *arg1 = (wxJoystick *) 0 ;
15605 int result;
15606 void *argp1 = 0 ;
15607 int res1 = 0 ;
15608 PyObject *swig_obj[1] ;
15609
15610 if (!args) SWIG_fail;
15611 swig_obj[0] = args;
15612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15613 if (!SWIG_IsOK(res1)) {
15614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
15615 }
15616 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15617 {
15618 PyThreadState* __tstate = wxPyBeginAllowThreads();
15619 result = (int)(arg1)->GetNumberJoysticks();
15620 wxPyEndAllowThreads(__tstate);
15621 if (PyErr_Occurred()) SWIG_fail;
15622 }
15623 resultobj = SWIG_From_int(static_cast< int >(result));
15624 return resultobj;
15625 fail:
15626 return NULL;
15627 }
15628
15629
15630 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15631 PyObject *resultobj = 0;
15632 wxJoystick *arg1 = (wxJoystick *) 0 ;
15633 int result;
15634 void *argp1 = 0 ;
15635 int res1 = 0 ;
15636 PyObject *swig_obj[1] ;
15637
15638 if (!args) SWIG_fail;
15639 swig_obj[0] = args;
15640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15641 if (!SWIG_IsOK(res1)) {
15642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15643 }
15644 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15645 {
15646 PyThreadState* __tstate = wxPyBeginAllowThreads();
15647 result = (int)(arg1)->GetManufacturerId();
15648 wxPyEndAllowThreads(__tstate);
15649 if (PyErr_Occurred()) SWIG_fail;
15650 }
15651 resultobj = SWIG_From_int(static_cast< int >(result));
15652 return resultobj;
15653 fail:
15654 return NULL;
15655 }
15656
15657
15658 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15659 PyObject *resultobj = 0;
15660 wxJoystick *arg1 = (wxJoystick *) 0 ;
15661 int result;
15662 void *argp1 = 0 ;
15663 int res1 = 0 ;
15664 PyObject *swig_obj[1] ;
15665
15666 if (!args) SWIG_fail;
15667 swig_obj[0] = args;
15668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15669 if (!SWIG_IsOK(res1)) {
15670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
15671 }
15672 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15673 {
15674 PyThreadState* __tstate = wxPyBeginAllowThreads();
15675 result = (int)(arg1)->GetProductId();
15676 wxPyEndAllowThreads(__tstate);
15677 if (PyErr_Occurred()) SWIG_fail;
15678 }
15679 resultobj = SWIG_From_int(static_cast< int >(result));
15680 return resultobj;
15681 fail:
15682 return NULL;
15683 }
15684
15685
15686 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15687 PyObject *resultobj = 0;
15688 wxJoystick *arg1 = (wxJoystick *) 0 ;
15689 wxString result;
15690 void *argp1 = 0 ;
15691 int res1 = 0 ;
15692 PyObject *swig_obj[1] ;
15693
15694 if (!args) SWIG_fail;
15695 swig_obj[0] = args;
15696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15697 if (!SWIG_IsOK(res1)) {
15698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
15699 }
15700 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15701 {
15702 PyThreadState* __tstate = wxPyBeginAllowThreads();
15703 result = (arg1)->GetProductName();
15704 wxPyEndAllowThreads(__tstate);
15705 if (PyErr_Occurred()) SWIG_fail;
15706 }
15707 {
15708 #if wxUSE_UNICODE
15709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15710 #else
15711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15712 #endif
15713 }
15714 return resultobj;
15715 fail:
15716 return NULL;
15717 }
15718
15719
15720 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15721 PyObject *resultobj = 0;
15722 wxJoystick *arg1 = (wxJoystick *) 0 ;
15723 int result;
15724 void *argp1 = 0 ;
15725 int res1 = 0 ;
15726 PyObject *swig_obj[1] ;
15727
15728 if (!args) SWIG_fail;
15729 swig_obj[0] = args;
15730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15731 if (!SWIG_IsOK(res1)) {
15732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15733 }
15734 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15735 {
15736 PyThreadState* __tstate = wxPyBeginAllowThreads();
15737 result = (int)(arg1)->GetXMin();
15738 wxPyEndAllowThreads(__tstate);
15739 if (PyErr_Occurred()) SWIG_fail;
15740 }
15741 resultobj = SWIG_From_int(static_cast< int >(result));
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15749 PyObject *resultobj = 0;
15750 wxJoystick *arg1 = (wxJoystick *) 0 ;
15751 int result;
15752 void *argp1 = 0 ;
15753 int res1 = 0 ;
15754 PyObject *swig_obj[1] ;
15755
15756 if (!args) SWIG_fail;
15757 swig_obj[0] = args;
15758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15759 if (!SWIG_IsOK(res1)) {
15760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15761 }
15762 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15763 {
15764 PyThreadState* __tstate = wxPyBeginAllowThreads();
15765 result = (int)(arg1)->GetYMin();
15766 wxPyEndAllowThreads(__tstate);
15767 if (PyErr_Occurred()) SWIG_fail;
15768 }
15769 resultobj = SWIG_From_int(static_cast< int >(result));
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15777 PyObject *resultobj = 0;
15778 wxJoystick *arg1 = (wxJoystick *) 0 ;
15779 int result;
15780 void *argp1 = 0 ;
15781 int res1 = 0 ;
15782 PyObject *swig_obj[1] ;
15783
15784 if (!args) SWIG_fail;
15785 swig_obj[0] = args;
15786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15789 }
15790 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15791 {
15792 PyThreadState* __tstate = wxPyBeginAllowThreads();
15793 result = (int)(arg1)->GetZMin();
15794 wxPyEndAllowThreads(__tstate);
15795 if (PyErr_Occurred()) SWIG_fail;
15796 }
15797 resultobj = SWIG_From_int(static_cast< int >(result));
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15805 PyObject *resultobj = 0;
15806 wxJoystick *arg1 = (wxJoystick *) 0 ;
15807 int result;
15808 void *argp1 = 0 ;
15809 int res1 = 0 ;
15810 PyObject *swig_obj[1] ;
15811
15812 if (!args) SWIG_fail;
15813 swig_obj[0] = args;
15814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15815 if (!SWIG_IsOK(res1)) {
15816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15817 }
15818 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15819 {
15820 PyThreadState* __tstate = wxPyBeginAllowThreads();
15821 result = (int)(arg1)->GetXMax();
15822 wxPyEndAllowThreads(__tstate);
15823 if (PyErr_Occurred()) SWIG_fail;
15824 }
15825 resultobj = SWIG_From_int(static_cast< int >(result));
15826 return resultobj;
15827 fail:
15828 return NULL;
15829 }
15830
15831
15832 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15833 PyObject *resultobj = 0;
15834 wxJoystick *arg1 = (wxJoystick *) 0 ;
15835 int result;
15836 void *argp1 = 0 ;
15837 int res1 = 0 ;
15838 PyObject *swig_obj[1] ;
15839
15840 if (!args) SWIG_fail;
15841 swig_obj[0] = args;
15842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15843 if (!SWIG_IsOK(res1)) {
15844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15845 }
15846 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15847 {
15848 PyThreadState* __tstate = wxPyBeginAllowThreads();
15849 result = (int)(arg1)->GetYMax();
15850 wxPyEndAllowThreads(__tstate);
15851 if (PyErr_Occurred()) SWIG_fail;
15852 }
15853 resultobj = SWIG_From_int(static_cast< int >(result));
15854 return resultobj;
15855 fail:
15856 return NULL;
15857 }
15858
15859
15860 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15861 PyObject *resultobj = 0;
15862 wxJoystick *arg1 = (wxJoystick *) 0 ;
15863 int result;
15864 void *argp1 = 0 ;
15865 int res1 = 0 ;
15866 PyObject *swig_obj[1] ;
15867
15868 if (!args) SWIG_fail;
15869 swig_obj[0] = args;
15870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15871 if (!SWIG_IsOK(res1)) {
15872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15873 }
15874 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 result = (int)(arg1)->GetZMax();
15878 wxPyEndAllowThreads(__tstate);
15879 if (PyErr_Occurred()) SWIG_fail;
15880 }
15881 resultobj = SWIG_From_int(static_cast< int >(result));
15882 return resultobj;
15883 fail:
15884 return NULL;
15885 }
15886
15887
15888 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15889 PyObject *resultobj = 0;
15890 wxJoystick *arg1 = (wxJoystick *) 0 ;
15891 int result;
15892 void *argp1 = 0 ;
15893 int res1 = 0 ;
15894 PyObject *swig_obj[1] ;
15895
15896 if (!args) SWIG_fail;
15897 swig_obj[0] = args;
15898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15899 if (!SWIG_IsOK(res1)) {
15900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15901 }
15902 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (int)(arg1)->GetNumberButtons();
15906 wxPyEndAllowThreads(__tstate);
15907 if (PyErr_Occurred()) SWIG_fail;
15908 }
15909 resultobj = SWIG_From_int(static_cast< int >(result));
15910 return resultobj;
15911 fail:
15912 return NULL;
15913 }
15914
15915
15916 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15917 PyObject *resultobj = 0;
15918 wxJoystick *arg1 = (wxJoystick *) 0 ;
15919 int result;
15920 void *argp1 = 0 ;
15921 int res1 = 0 ;
15922 PyObject *swig_obj[1] ;
15923
15924 if (!args) SWIG_fail;
15925 swig_obj[0] = args;
15926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15927 if (!SWIG_IsOK(res1)) {
15928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15929 }
15930 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 result = (int)(arg1)->GetNumberAxes();
15934 wxPyEndAllowThreads(__tstate);
15935 if (PyErr_Occurred()) SWIG_fail;
15936 }
15937 resultobj = SWIG_From_int(static_cast< int >(result));
15938 return resultobj;
15939 fail:
15940 return NULL;
15941 }
15942
15943
15944 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15945 PyObject *resultobj = 0;
15946 wxJoystick *arg1 = (wxJoystick *) 0 ;
15947 int result;
15948 void *argp1 = 0 ;
15949 int res1 = 0 ;
15950 PyObject *swig_obj[1] ;
15951
15952 if (!args) SWIG_fail;
15953 swig_obj[0] = args;
15954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15955 if (!SWIG_IsOK(res1)) {
15956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
15957 }
15958 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15959 {
15960 PyThreadState* __tstate = wxPyBeginAllowThreads();
15961 result = (int)(arg1)->GetMaxButtons();
15962 wxPyEndAllowThreads(__tstate);
15963 if (PyErr_Occurred()) SWIG_fail;
15964 }
15965 resultobj = SWIG_From_int(static_cast< int >(result));
15966 return resultobj;
15967 fail:
15968 return NULL;
15969 }
15970
15971
15972 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15973 PyObject *resultobj = 0;
15974 wxJoystick *arg1 = (wxJoystick *) 0 ;
15975 int result;
15976 void *argp1 = 0 ;
15977 int res1 = 0 ;
15978 PyObject *swig_obj[1] ;
15979
15980 if (!args) SWIG_fail;
15981 swig_obj[0] = args;
15982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15983 if (!SWIG_IsOK(res1)) {
15984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
15985 }
15986 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15987 {
15988 PyThreadState* __tstate = wxPyBeginAllowThreads();
15989 result = (int)(arg1)->GetMaxAxes();
15990 wxPyEndAllowThreads(__tstate);
15991 if (PyErr_Occurred()) SWIG_fail;
15992 }
15993 resultobj = SWIG_From_int(static_cast< int >(result));
15994 return resultobj;
15995 fail:
15996 return NULL;
15997 }
15998
15999
16000 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16001 PyObject *resultobj = 0;
16002 wxJoystick *arg1 = (wxJoystick *) 0 ;
16003 int result;
16004 void *argp1 = 0 ;
16005 int res1 = 0 ;
16006 PyObject *swig_obj[1] ;
16007
16008 if (!args) SWIG_fail;
16009 swig_obj[0] = args;
16010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16011 if (!SWIG_IsOK(res1)) {
16012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16013 }
16014 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16015 {
16016 PyThreadState* __tstate = wxPyBeginAllowThreads();
16017 result = (int)(arg1)->GetPollingMin();
16018 wxPyEndAllowThreads(__tstate);
16019 if (PyErr_Occurred()) SWIG_fail;
16020 }
16021 resultobj = SWIG_From_int(static_cast< int >(result));
16022 return resultobj;
16023 fail:
16024 return NULL;
16025 }
16026
16027
16028 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16029 PyObject *resultobj = 0;
16030 wxJoystick *arg1 = (wxJoystick *) 0 ;
16031 int result;
16032 void *argp1 = 0 ;
16033 int res1 = 0 ;
16034 PyObject *swig_obj[1] ;
16035
16036 if (!args) SWIG_fail;
16037 swig_obj[0] = args;
16038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16039 if (!SWIG_IsOK(res1)) {
16040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16041 }
16042 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16043 {
16044 PyThreadState* __tstate = wxPyBeginAllowThreads();
16045 result = (int)(arg1)->GetPollingMax();
16046 wxPyEndAllowThreads(__tstate);
16047 if (PyErr_Occurred()) SWIG_fail;
16048 }
16049 resultobj = SWIG_From_int(static_cast< int >(result));
16050 return resultobj;
16051 fail:
16052 return NULL;
16053 }
16054
16055
16056 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16057 PyObject *resultobj = 0;
16058 wxJoystick *arg1 = (wxJoystick *) 0 ;
16059 int result;
16060 void *argp1 = 0 ;
16061 int res1 = 0 ;
16062 PyObject *swig_obj[1] ;
16063
16064 if (!args) SWIG_fail;
16065 swig_obj[0] = args;
16066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16069 }
16070 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16071 {
16072 PyThreadState* __tstate = wxPyBeginAllowThreads();
16073 result = (int)(arg1)->GetRudderMin();
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_From_int(static_cast< int >(result));
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16085 PyObject *resultobj = 0;
16086 wxJoystick *arg1 = (wxJoystick *) 0 ;
16087 int result;
16088 void *argp1 = 0 ;
16089 int res1 = 0 ;
16090 PyObject *swig_obj[1] ;
16091
16092 if (!args) SWIG_fail;
16093 swig_obj[0] = args;
16094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16095 if (!SWIG_IsOK(res1)) {
16096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16097 }
16098 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 result = (int)(arg1)->GetRudderMax();
16102 wxPyEndAllowThreads(__tstate);
16103 if (PyErr_Occurred()) SWIG_fail;
16104 }
16105 resultobj = SWIG_From_int(static_cast< int >(result));
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16113 PyObject *resultobj = 0;
16114 wxJoystick *arg1 = (wxJoystick *) 0 ;
16115 int result;
16116 void *argp1 = 0 ;
16117 int res1 = 0 ;
16118 PyObject *swig_obj[1] ;
16119
16120 if (!args) SWIG_fail;
16121 swig_obj[0] = args;
16122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16123 if (!SWIG_IsOK(res1)) {
16124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16125 }
16126 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16127 {
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 result = (int)(arg1)->GetUMin();
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 resultobj = SWIG_From_int(static_cast< int >(result));
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16141 PyObject *resultobj = 0;
16142 wxJoystick *arg1 = (wxJoystick *) 0 ;
16143 int result;
16144 void *argp1 = 0 ;
16145 int res1 = 0 ;
16146 PyObject *swig_obj[1] ;
16147
16148 if (!args) SWIG_fail;
16149 swig_obj[0] = args;
16150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16151 if (!SWIG_IsOK(res1)) {
16152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16153 }
16154 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16155 {
16156 PyThreadState* __tstate = wxPyBeginAllowThreads();
16157 result = (int)(arg1)->GetUMax();
16158 wxPyEndAllowThreads(__tstate);
16159 if (PyErr_Occurred()) SWIG_fail;
16160 }
16161 resultobj = SWIG_From_int(static_cast< int >(result));
16162 return resultobj;
16163 fail:
16164 return NULL;
16165 }
16166
16167
16168 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16169 PyObject *resultobj = 0;
16170 wxJoystick *arg1 = (wxJoystick *) 0 ;
16171 int result;
16172 void *argp1 = 0 ;
16173 int res1 = 0 ;
16174 PyObject *swig_obj[1] ;
16175
16176 if (!args) SWIG_fail;
16177 swig_obj[0] = args;
16178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16179 if (!SWIG_IsOK(res1)) {
16180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
16181 }
16182 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16183 {
16184 PyThreadState* __tstate = wxPyBeginAllowThreads();
16185 result = (int)(arg1)->GetVMin();
16186 wxPyEndAllowThreads(__tstate);
16187 if (PyErr_Occurred()) SWIG_fail;
16188 }
16189 resultobj = SWIG_From_int(static_cast< int >(result));
16190 return resultobj;
16191 fail:
16192 return NULL;
16193 }
16194
16195
16196 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16197 PyObject *resultobj = 0;
16198 wxJoystick *arg1 = (wxJoystick *) 0 ;
16199 int result;
16200 void *argp1 = 0 ;
16201 int res1 = 0 ;
16202 PyObject *swig_obj[1] ;
16203
16204 if (!args) SWIG_fail;
16205 swig_obj[0] = args;
16206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16207 if (!SWIG_IsOK(res1)) {
16208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
16209 }
16210 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16211 {
16212 PyThreadState* __tstate = wxPyBeginAllowThreads();
16213 result = (int)(arg1)->GetVMax();
16214 wxPyEndAllowThreads(__tstate);
16215 if (PyErr_Occurred()) SWIG_fail;
16216 }
16217 resultobj = SWIG_From_int(static_cast< int >(result));
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16225 PyObject *resultobj = 0;
16226 wxJoystick *arg1 = (wxJoystick *) 0 ;
16227 bool result;
16228 void *argp1 = 0 ;
16229 int res1 = 0 ;
16230 PyObject *swig_obj[1] ;
16231
16232 if (!args) SWIG_fail;
16233 swig_obj[0] = args;
16234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16235 if (!SWIG_IsOK(res1)) {
16236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
16237 }
16238 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16239 {
16240 PyThreadState* __tstate = wxPyBeginAllowThreads();
16241 result = (bool)(arg1)->HasRudder();
16242 wxPyEndAllowThreads(__tstate);
16243 if (PyErr_Occurred()) SWIG_fail;
16244 }
16245 {
16246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16247 }
16248 return resultobj;
16249 fail:
16250 return NULL;
16251 }
16252
16253
16254 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16255 PyObject *resultobj = 0;
16256 wxJoystick *arg1 = (wxJoystick *) 0 ;
16257 bool result;
16258 void *argp1 = 0 ;
16259 int res1 = 0 ;
16260 PyObject *swig_obj[1] ;
16261
16262 if (!args) SWIG_fail;
16263 swig_obj[0] = args;
16264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16265 if (!SWIG_IsOK(res1)) {
16266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
16267 }
16268 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16269 {
16270 PyThreadState* __tstate = wxPyBeginAllowThreads();
16271 result = (bool)(arg1)->HasZ();
16272 wxPyEndAllowThreads(__tstate);
16273 if (PyErr_Occurred()) SWIG_fail;
16274 }
16275 {
16276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16277 }
16278 return resultobj;
16279 fail:
16280 return NULL;
16281 }
16282
16283
16284 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16285 PyObject *resultobj = 0;
16286 wxJoystick *arg1 = (wxJoystick *) 0 ;
16287 bool result;
16288 void *argp1 = 0 ;
16289 int res1 = 0 ;
16290 PyObject *swig_obj[1] ;
16291
16292 if (!args) SWIG_fail;
16293 swig_obj[0] = args;
16294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
16297 }
16298 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 result = (bool)(arg1)->HasU();
16302 wxPyEndAllowThreads(__tstate);
16303 if (PyErr_Occurred()) SWIG_fail;
16304 }
16305 {
16306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16307 }
16308 return resultobj;
16309 fail:
16310 return NULL;
16311 }
16312
16313
16314 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16315 PyObject *resultobj = 0;
16316 wxJoystick *arg1 = (wxJoystick *) 0 ;
16317 bool result;
16318 void *argp1 = 0 ;
16319 int res1 = 0 ;
16320 PyObject *swig_obj[1] ;
16321
16322 if (!args) SWIG_fail;
16323 swig_obj[0] = args;
16324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16325 if (!SWIG_IsOK(res1)) {
16326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16327 }
16328 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16329 {
16330 PyThreadState* __tstate = wxPyBeginAllowThreads();
16331 result = (bool)(arg1)->HasV();
16332 wxPyEndAllowThreads(__tstate);
16333 if (PyErr_Occurred()) SWIG_fail;
16334 }
16335 {
16336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16337 }
16338 return resultobj;
16339 fail:
16340 return NULL;
16341 }
16342
16343
16344 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16345 PyObject *resultobj = 0;
16346 wxJoystick *arg1 = (wxJoystick *) 0 ;
16347 bool result;
16348 void *argp1 = 0 ;
16349 int res1 = 0 ;
16350 PyObject *swig_obj[1] ;
16351
16352 if (!args) SWIG_fail;
16353 swig_obj[0] = args;
16354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16355 if (!SWIG_IsOK(res1)) {
16356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
16357 }
16358 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16359 {
16360 PyThreadState* __tstate = wxPyBeginAllowThreads();
16361 result = (bool)(arg1)->HasPOV();
16362 wxPyEndAllowThreads(__tstate);
16363 if (PyErr_Occurred()) SWIG_fail;
16364 }
16365 {
16366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16367 }
16368 return resultobj;
16369 fail:
16370 return NULL;
16371 }
16372
16373
16374 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16375 PyObject *resultobj = 0;
16376 wxJoystick *arg1 = (wxJoystick *) 0 ;
16377 bool result;
16378 void *argp1 = 0 ;
16379 int res1 = 0 ;
16380 PyObject *swig_obj[1] ;
16381
16382 if (!args) SWIG_fail;
16383 swig_obj[0] = args;
16384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16385 if (!SWIG_IsOK(res1)) {
16386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
16387 }
16388 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16389 {
16390 PyThreadState* __tstate = wxPyBeginAllowThreads();
16391 result = (bool)(arg1)->HasPOV4Dir();
16392 wxPyEndAllowThreads(__tstate);
16393 if (PyErr_Occurred()) SWIG_fail;
16394 }
16395 {
16396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16397 }
16398 return resultobj;
16399 fail:
16400 return NULL;
16401 }
16402
16403
16404 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16405 PyObject *resultobj = 0;
16406 wxJoystick *arg1 = (wxJoystick *) 0 ;
16407 bool result;
16408 void *argp1 = 0 ;
16409 int res1 = 0 ;
16410 PyObject *swig_obj[1] ;
16411
16412 if (!args) SWIG_fail;
16413 swig_obj[0] = args;
16414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16415 if (!SWIG_IsOK(res1)) {
16416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
16417 }
16418 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 result = (bool)(arg1)->HasPOVCTS();
16422 wxPyEndAllowThreads(__tstate);
16423 if (PyErr_Occurred()) SWIG_fail;
16424 }
16425 {
16426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16427 }
16428 return resultobj;
16429 fail:
16430 return NULL;
16431 }
16432
16433
16434 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16435 PyObject *resultobj = 0;
16436 wxJoystick *arg1 = (wxJoystick *) 0 ;
16437 wxWindow *arg2 = (wxWindow *) 0 ;
16438 int arg3 = (int) 0 ;
16439 bool result;
16440 void *argp1 = 0 ;
16441 int res1 = 0 ;
16442 void *argp2 = 0 ;
16443 int res2 = 0 ;
16444 int val3 ;
16445 int ecode3 = 0 ;
16446 PyObject * obj0 = 0 ;
16447 PyObject * obj1 = 0 ;
16448 PyObject * obj2 = 0 ;
16449 char * kwnames[] = {
16450 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
16451 };
16452
16453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16455 if (!SWIG_IsOK(res1)) {
16456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16457 }
16458 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16459 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
16460 if (!SWIG_IsOK(res2)) {
16461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
16462 }
16463 arg2 = reinterpret_cast< wxWindow * >(argp2);
16464 if (obj2) {
16465 ecode3 = SWIG_AsVal_int(obj2, &val3);
16466 if (!SWIG_IsOK(ecode3)) {
16467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
16468 }
16469 arg3 = static_cast< int >(val3);
16470 }
16471 {
16472 PyThreadState* __tstate = wxPyBeginAllowThreads();
16473 result = (bool)(arg1)->SetCapture(arg2,arg3);
16474 wxPyEndAllowThreads(__tstate);
16475 if (PyErr_Occurred()) SWIG_fail;
16476 }
16477 {
16478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16479 }
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16487 PyObject *resultobj = 0;
16488 wxJoystick *arg1 = (wxJoystick *) 0 ;
16489 bool result;
16490 void *argp1 = 0 ;
16491 int res1 = 0 ;
16492 PyObject *swig_obj[1] ;
16493
16494 if (!args) SWIG_fail;
16495 swig_obj[0] = args;
16496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
16497 if (!SWIG_IsOK(res1)) {
16498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
16499 }
16500 arg1 = reinterpret_cast< wxJoystick * >(argp1);
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 result = (bool)(arg1)->ReleaseCapture();
16504 wxPyEndAllowThreads(__tstate);
16505 if (PyErr_Occurred()) SWIG_fail;
16506 }
16507 {
16508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16509 }
16510 return resultobj;
16511 fail:
16512 return NULL;
16513 }
16514
16515
16516 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16517 PyObject *obj;
16518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16519 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
16520 return SWIG_Py_Void();
16521 }
16522
16523 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16524 return SWIG_Python_InitShadowInstance(args);
16525 }
16526
16527 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16528 PyObject *resultobj = 0;
16529 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16530 int arg2 = (int) 0 ;
16531 int arg3 = (int) wxJOYSTICK1 ;
16532 int arg4 = (int) 0 ;
16533 wxJoystickEvent *result = 0 ;
16534 int val1 ;
16535 int ecode1 = 0 ;
16536 int val2 ;
16537 int ecode2 = 0 ;
16538 int val3 ;
16539 int ecode3 = 0 ;
16540 int val4 ;
16541 int ecode4 = 0 ;
16542 PyObject * obj0 = 0 ;
16543 PyObject * obj1 = 0 ;
16544 PyObject * obj2 = 0 ;
16545 PyObject * obj3 = 0 ;
16546 char * kwnames[] = {
16547 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
16548 };
16549
16550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16551 if (obj0) {
16552 ecode1 = SWIG_AsVal_int(obj0, &val1);
16553 if (!SWIG_IsOK(ecode1)) {
16554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
16555 }
16556 arg1 = static_cast< wxEventType >(val1);
16557 }
16558 if (obj1) {
16559 ecode2 = SWIG_AsVal_int(obj1, &val2);
16560 if (!SWIG_IsOK(ecode2)) {
16561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
16562 }
16563 arg2 = static_cast< int >(val2);
16564 }
16565 if (obj2) {
16566 ecode3 = SWIG_AsVal_int(obj2, &val3);
16567 if (!SWIG_IsOK(ecode3)) {
16568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
16569 }
16570 arg3 = static_cast< int >(val3);
16571 }
16572 if (obj3) {
16573 ecode4 = SWIG_AsVal_int(obj3, &val4);
16574 if (!SWIG_IsOK(ecode4)) {
16575 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
16576 }
16577 arg4 = static_cast< int >(val4);
16578 }
16579 {
16580 PyThreadState* __tstate = wxPyBeginAllowThreads();
16581 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
16582 wxPyEndAllowThreads(__tstate);
16583 if (PyErr_Occurred()) SWIG_fail;
16584 }
16585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
16586 return resultobj;
16587 fail:
16588 return NULL;
16589 }
16590
16591
16592 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16593 PyObject *resultobj = 0;
16594 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16595 wxPoint result;
16596 void *argp1 = 0 ;
16597 int res1 = 0 ;
16598 PyObject *swig_obj[1] ;
16599
16600 if (!args) SWIG_fail;
16601 swig_obj[0] = args;
16602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16603 if (!SWIG_IsOK(res1)) {
16604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16605 }
16606 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16607 {
16608 PyThreadState* __tstate = wxPyBeginAllowThreads();
16609 result = ((wxJoystickEvent const *)arg1)->GetPosition();
16610 wxPyEndAllowThreads(__tstate);
16611 if (PyErr_Occurred()) SWIG_fail;
16612 }
16613 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
16614 return resultobj;
16615 fail:
16616 return NULL;
16617 }
16618
16619
16620 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16621 PyObject *resultobj = 0;
16622 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16623 int result;
16624 void *argp1 = 0 ;
16625 int res1 = 0 ;
16626 PyObject *swig_obj[1] ;
16627
16628 if (!args) SWIG_fail;
16629 swig_obj[0] = args;
16630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16631 if (!SWIG_IsOK(res1)) {
16632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16633 }
16634 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16635 {
16636 PyThreadState* __tstate = wxPyBeginAllowThreads();
16637 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 resultobj = SWIG_From_int(static_cast< int >(result));
16642 return resultobj;
16643 fail:
16644 return NULL;
16645 }
16646
16647
16648 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16649 PyObject *resultobj = 0;
16650 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16651 int result;
16652 void *argp1 = 0 ;
16653 int res1 = 0 ;
16654 PyObject *swig_obj[1] ;
16655
16656 if (!args) SWIG_fail;
16657 swig_obj[0] = args;
16658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16659 if (!SWIG_IsOK(res1)) {
16660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16661 }
16662 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16663 {
16664 PyThreadState* __tstate = wxPyBeginAllowThreads();
16665 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
16666 wxPyEndAllowThreads(__tstate);
16667 if (PyErr_Occurred()) SWIG_fail;
16668 }
16669 resultobj = SWIG_From_int(static_cast< int >(result));
16670 return resultobj;
16671 fail:
16672 return NULL;
16673 }
16674
16675
16676 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16677 PyObject *resultobj = 0;
16678 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16679 int result;
16680 void *argp1 = 0 ;
16681 int res1 = 0 ;
16682 PyObject *swig_obj[1] ;
16683
16684 if (!args) SWIG_fail;
16685 swig_obj[0] = args;
16686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16687 if (!SWIG_IsOK(res1)) {
16688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16689 }
16690 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16691 {
16692 PyThreadState* __tstate = wxPyBeginAllowThreads();
16693 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 resultobj = SWIG_From_int(static_cast< int >(result));
16698 return resultobj;
16699 fail:
16700 return NULL;
16701 }
16702
16703
16704 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16705 PyObject *resultobj = 0;
16706 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16707 int result;
16708 void *argp1 = 0 ;
16709 int res1 = 0 ;
16710 PyObject *swig_obj[1] ;
16711
16712 if (!args) SWIG_fail;
16713 swig_obj[0] = args;
16714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16715 if (!SWIG_IsOK(res1)) {
16716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16717 }
16718 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 resultobj = SWIG_From_int(static_cast< int >(result));
16726 return resultobj;
16727 fail:
16728 return NULL;
16729 }
16730
16731
16732 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16733 PyObject *resultobj = 0;
16734 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16735 int arg2 ;
16736 void *argp1 = 0 ;
16737 int res1 = 0 ;
16738 int val2 ;
16739 int ecode2 = 0 ;
16740 PyObject * obj0 = 0 ;
16741 PyObject * obj1 = 0 ;
16742 char * kwnames[] = {
16743 (char *) "self",(char *) "stick", NULL
16744 };
16745
16746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
16747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16748 if (!SWIG_IsOK(res1)) {
16749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16750 }
16751 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16752 ecode2 = SWIG_AsVal_int(obj1, &val2);
16753 if (!SWIG_IsOK(ecode2)) {
16754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
16755 }
16756 arg2 = static_cast< int >(val2);
16757 {
16758 PyThreadState* __tstate = wxPyBeginAllowThreads();
16759 (arg1)->SetJoystick(arg2);
16760 wxPyEndAllowThreads(__tstate);
16761 if (PyErr_Occurred()) SWIG_fail;
16762 }
16763 resultobj = SWIG_Py_Void();
16764 return resultobj;
16765 fail:
16766 return NULL;
16767 }
16768
16769
16770 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16771 PyObject *resultobj = 0;
16772 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16773 int arg2 ;
16774 void *argp1 = 0 ;
16775 int res1 = 0 ;
16776 int val2 ;
16777 int ecode2 = 0 ;
16778 PyObject * obj0 = 0 ;
16779 PyObject * obj1 = 0 ;
16780 char * kwnames[] = {
16781 (char *) "self",(char *) "state", NULL
16782 };
16783
16784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
16785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16786 if (!SWIG_IsOK(res1)) {
16787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16788 }
16789 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16790 ecode2 = SWIG_AsVal_int(obj1, &val2);
16791 if (!SWIG_IsOK(ecode2)) {
16792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
16793 }
16794 arg2 = static_cast< int >(val2);
16795 {
16796 PyThreadState* __tstate = wxPyBeginAllowThreads();
16797 (arg1)->SetButtonState(arg2);
16798 wxPyEndAllowThreads(__tstate);
16799 if (PyErr_Occurred()) SWIG_fail;
16800 }
16801 resultobj = SWIG_Py_Void();
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16809 PyObject *resultobj = 0;
16810 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16811 int arg2 ;
16812 void *argp1 = 0 ;
16813 int res1 = 0 ;
16814 int val2 ;
16815 int ecode2 = 0 ;
16816 PyObject * obj0 = 0 ;
16817 PyObject * obj1 = 0 ;
16818 char * kwnames[] = {
16819 (char *) "self",(char *) "change", NULL
16820 };
16821
16822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
16823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16824 if (!SWIG_IsOK(res1)) {
16825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16826 }
16827 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16828 ecode2 = SWIG_AsVal_int(obj1, &val2);
16829 if (!SWIG_IsOK(ecode2)) {
16830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
16831 }
16832 arg2 = static_cast< int >(val2);
16833 {
16834 PyThreadState* __tstate = wxPyBeginAllowThreads();
16835 (arg1)->SetButtonChange(arg2);
16836 wxPyEndAllowThreads(__tstate);
16837 if (PyErr_Occurred()) SWIG_fail;
16838 }
16839 resultobj = SWIG_Py_Void();
16840 return resultobj;
16841 fail:
16842 return NULL;
16843 }
16844
16845
16846 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj = 0;
16848 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16849 wxPoint *arg2 = 0 ;
16850 void *argp1 = 0 ;
16851 int res1 = 0 ;
16852 wxPoint temp2 ;
16853 PyObject * obj0 = 0 ;
16854 PyObject * obj1 = 0 ;
16855 char * kwnames[] = {
16856 (char *) "self",(char *) "pos", NULL
16857 };
16858
16859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16861 if (!SWIG_IsOK(res1)) {
16862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16863 }
16864 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16865 {
16866 arg2 = &temp2;
16867 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
16868 }
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 (arg1)->SetPosition((wxPoint const &)*arg2);
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 resultobj = SWIG_Py_Void();
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj = 0;
16884 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16885 int arg2 ;
16886 void *argp1 = 0 ;
16887 int res1 = 0 ;
16888 int val2 ;
16889 int ecode2 = 0 ;
16890 PyObject * obj0 = 0 ;
16891 PyObject * obj1 = 0 ;
16892 char * kwnames[] = {
16893 (char *) "self",(char *) "zPos", NULL
16894 };
16895
16896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
16897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16898 if (!SWIG_IsOK(res1)) {
16899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
16900 }
16901 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16902 ecode2 = SWIG_AsVal_int(obj1, &val2);
16903 if (!SWIG_IsOK(ecode2)) {
16904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
16905 }
16906 arg2 = static_cast< int >(val2);
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 (arg1)->SetZPosition(arg2);
16910 wxPyEndAllowThreads(__tstate);
16911 if (PyErr_Occurred()) SWIG_fail;
16912 }
16913 resultobj = SWIG_Py_Void();
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16921 PyObject *resultobj = 0;
16922 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16923 bool result;
16924 void *argp1 = 0 ;
16925 int res1 = 0 ;
16926 PyObject *swig_obj[1] ;
16927
16928 if (!args) SWIG_fail;
16929 swig_obj[0] = args;
16930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16931 if (!SWIG_IsOK(res1)) {
16932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16933 }
16934 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16935 {
16936 PyThreadState* __tstate = wxPyBeginAllowThreads();
16937 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
16938 wxPyEndAllowThreads(__tstate);
16939 if (PyErr_Occurred()) SWIG_fail;
16940 }
16941 {
16942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16943 }
16944 return resultobj;
16945 fail:
16946 return NULL;
16947 }
16948
16949
16950 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16951 PyObject *resultobj = 0;
16952 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16953 bool result;
16954 void *argp1 = 0 ;
16955 int res1 = 0 ;
16956 PyObject *swig_obj[1] ;
16957
16958 if (!args) SWIG_fail;
16959 swig_obj[0] = args;
16960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16961 if (!SWIG_IsOK(res1)) {
16962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16963 }
16964 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16965 {
16966 PyThreadState* __tstate = wxPyBeginAllowThreads();
16967 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
16968 wxPyEndAllowThreads(__tstate);
16969 if (PyErr_Occurred()) SWIG_fail;
16970 }
16971 {
16972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16973 }
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16981 PyObject *resultobj = 0;
16982 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
16983 bool result;
16984 void *argp1 = 0 ;
16985 int res1 = 0 ;
16986 PyObject *swig_obj[1] ;
16987
16988 if (!args) SWIG_fail;
16989 swig_obj[0] = args;
16990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
16991 if (!SWIG_IsOK(res1)) {
16992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
16993 }
16994 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
16995 {
16996 PyThreadState* __tstate = wxPyBeginAllowThreads();
16997 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
16998 wxPyEndAllowThreads(__tstate);
16999 if (PyErr_Occurred()) SWIG_fail;
17000 }
17001 {
17002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17003 }
17004 return resultobj;
17005 fail:
17006 return NULL;
17007 }
17008
17009
17010 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17011 PyObject *resultobj = 0;
17012 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17013 int arg2 = (int) wxJOY_BUTTON_ANY ;
17014 bool result;
17015 void *argp1 = 0 ;
17016 int res1 = 0 ;
17017 int val2 ;
17018 int ecode2 = 0 ;
17019 PyObject * obj0 = 0 ;
17020 PyObject * obj1 = 0 ;
17021 char * kwnames[] = {
17022 (char *) "self",(char *) "but", NULL
17023 };
17024
17025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
17026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17027 if (!SWIG_IsOK(res1)) {
17028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17029 }
17030 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17031 if (obj1) {
17032 ecode2 = SWIG_AsVal_int(obj1, &val2);
17033 if (!SWIG_IsOK(ecode2)) {
17034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
17035 }
17036 arg2 = static_cast< int >(val2);
17037 }
17038 {
17039 PyThreadState* __tstate = wxPyBeginAllowThreads();
17040 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 {
17045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17046 }
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17054 PyObject *resultobj = 0;
17055 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17056 int arg2 = (int) wxJOY_BUTTON_ANY ;
17057 bool result;
17058 void *argp1 = 0 ;
17059 int res1 = 0 ;
17060 int val2 ;
17061 int ecode2 = 0 ;
17062 PyObject * obj0 = 0 ;
17063 PyObject * obj1 = 0 ;
17064 char * kwnames[] = {
17065 (char *) "self",(char *) "but", NULL
17066 };
17067
17068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
17069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17070 if (!SWIG_IsOK(res1)) {
17071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17072 }
17073 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17074 if (obj1) {
17075 ecode2 = SWIG_AsVal_int(obj1, &val2);
17076 if (!SWIG_IsOK(ecode2)) {
17077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
17078 }
17079 arg2 = static_cast< int >(val2);
17080 }
17081 {
17082 PyThreadState* __tstate = wxPyBeginAllowThreads();
17083 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
17084 wxPyEndAllowThreads(__tstate);
17085 if (PyErr_Occurred()) SWIG_fail;
17086 }
17087 {
17088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17089 }
17090 return resultobj;
17091 fail:
17092 return NULL;
17093 }
17094
17095
17096 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17097 PyObject *resultobj = 0;
17098 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
17099 int arg2 = (int) wxJOY_BUTTON_ANY ;
17100 bool result;
17101 void *argp1 = 0 ;
17102 int res1 = 0 ;
17103 int val2 ;
17104 int ecode2 = 0 ;
17105 PyObject * obj0 = 0 ;
17106 PyObject * obj1 = 0 ;
17107 char * kwnames[] = {
17108 (char *) "self",(char *) "but", NULL
17109 };
17110
17111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
17112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
17113 if (!SWIG_IsOK(res1)) {
17114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
17115 }
17116 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
17117 if (obj1) {
17118 ecode2 = SWIG_AsVal_int(obj1, &val2);
17119 if (!SWIG_IsOK(ecode2)) {
17120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
17121 }
17122 arg2 = static_cast< int >(val2);
17123 }
17124 {
17125 PyThreadState* __tstate = wxPyBeginAllowThreads();
17126 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
17127 wxPyEndAllowThreads(__tstate);
17128 if (PyErr_Occurred()) SWIG_fail;
17129 }
17130 {
17131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17132 }
17133 return resultobj;
17134 fail:
17135 return NULL;
17136 }
17137
17138
17139 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17140 PyObject *obj;
17141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17142 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
17143 return SWIG_Py_Void();
17144 }
17145
17146 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17147 return SWIG_Python_InitShadowInstance(args);
17148 }
17149
17150 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj = 0;
17152 wxString const &arg1_defvalue = wxPyEmptyString ;
17153 wxString *arg1 = (wxString *) &arg1_defvalue ;
17154 wxSound *result = 0 ;
17155 bool temp1 = false ;
17156 PyObject * obj0 = 0 ;
17157 char * kwnames[] = {
17158 (char *) "fileName", NULL
17159 };
17160
17161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
17162 if (obj0) {
17163 {
17164 arg1 = wxString_in_helper(obj0);
17165 if (arg1 == NULL) SWIG_fail;
17166 temp1 = true;
17167 }
17168 }
17169 {
17170 if (!wxPyCheckForApp()) SWIG_fail;
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 result = (wxSound *)new_wxSound((wxString const &)*arg1);
17173 wxPyEndAllowThreads(__tstate);
17174 if (PyErr_Occurred()) SWIG_fail;
17175 }
17176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
17177 {
17178 if (temp1)
17179 delete arg1;
17180 }
17181 return resultobj;
17182 fail:
17183 {
17184 if (temp1)
17185 delete arg1;
17186 }
17187 return NULL;
17188 }
17189
17190
17191 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17192 PyObject *resultobj = 0;
17193 PyObject *arg1 = (PyObject *) 0 ;
17194 wxSound *result = 0 ;
17195 PyObject * obj0 = 0 ;
17196 char * kwnames[] = {
17197 (char *) "data", NULL
17198 };
17199
17200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
17201 arg1 = obj0;
17202 {
17203 if (!wxPyCheckForApp()) SWIG_fail;
17204 PyThreadState* __tstate = wxPyBeginAllowThreads();
17205 result = (wxSound *)new_wxSound(arg1);
17206 wxPyEndAllowThreads(__tstate);
17207 if (PyErr_Occurred()) SWIG_fail;
17208 }
17209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
17210 return resultobj;
17211 fail:
17212 return NULL;
17213 }
17214
17215
17216 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17217 PyObject *resultobj = 0;
17218 wxSound *arg1 = (wxSound *) 0 ;
17219 void *argp1 = 0 ;
17220 int res1 = 0 ;
17221 PyObject *swig_obj[1] ;
17222
17223 if (!args) SWIG_fail;
17224 swig_obj[0] = args;
17225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
17226 if (!SWIG_IsOK(res1)) {
17227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
17228 }
17229 arg1 = reinterpret_cast< wxSound * >(argp1);
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 delete arg1;
17233
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 resultobj = SWIG_Py_Void();
17238 return resultobj;
17239 fail:
17240 return NULL;
17241 }
17242
17243
17244 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17245 PyObject *resultobj = 0;
17246 wxSound *arg1 = (wxSound *) 0 ;
17247 wxString *arg2 = 0 ;
17248 bool result;
17249 void *argp1 = 0 ;
17250 int res1 = 0 ;
17251 bool temp2 = false ;
17252 PyObject * obj0 = 0 ;
17253 PyObject * obj1 = 0 ;
17254 char * kwnames[] = {
17255 (char *) "self",(char *) "fileName", NULL
17256 };
17257
17258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
17259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17260 if (!SWIG_IsOK(res1)) {
17261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
17262 }
17263 arg1 = reinterpret_cast< wxSound * >(argp1);
17264 {
17265 arg2 = wxString_in_helper(obj1);
17266 if (arg2 == NULL) SWIG_fail;
17267 temp2 = true;
17268 }
17269 {
17270 PyThreadState* __tstate = wxPyBeginAllowThreads();
17271 result = (bool)(arg1)->Create((wxString const &)*arg2);
17272 wxPyEndAllowThreads(__tstate);
17273 if (PyErr_Occurred()) SWIG_fail;
17274 }
17275 {
17276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17277 }
17278 {
17279 if (temp2)
17280 delete arg2;
17281 }
17282 return resultobj;
17283 fail:
17284 {
17285 if (temp2)
17286 delete arg2;
17287 }
17288 return NULL;
17289 }
17290
17291
17292 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17293 PyObject *resultobj = 0;
17294 wxSound *arg1 = (wxSound *) 0 ;
17295 PyObject *arg2 = (PyObject *) 0 ;
17296 bool result;
17297 void *argp1 = 0 ;
17298 int res1 = 0 ;
17299 PyObject * obj0 = 0 ;
17300 PyObject * obj1 = 0 ;
17301 char * kwnames[] = {
17302 (char *) "self",(char *) "data", NULL
17303 };
17304
17305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
17306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17307 if (!SWIG_IsOK(res1)) {
17308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
17309 }
17310 arg1 = reinterpret_cast< wxSound * >(argp1);
17311 arg2 = obj1;
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (bool)wxSound_CreateFromData(arg1,arg2);
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 {
17319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17320 }
17321 return resultobj;
17322 fail:
17323 return NULL;
17324 }
17325
17326
17327 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17328 PyObject *resultobj = 0;
17329 wxSound *arg1 = (wxSound *) 0 ;
17330 bool result;
17331 void *argp1 = 0 ;
17332 int res1 = 0 ;
17333 PyObject *swig_obj[1] ;
17334
17335 if (!args) SWIG_fail;
17336 swig_obj[0] = args;
17337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17338 if (!SWIG_IsOK(res1)) {
17339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
17340 }
17341 arg1 = reinterpret_cast< wxSound * >(argp1);
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = (bool)(arg1)->IsOk();
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17350 }
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj = 0;
17359 wxSound *arg1 = (wxSound *) 0 ;
17360 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17361 bool result;
17362 void *argp1 = 0 ;
17363 int res1 = 0 ;
17364 unsigned int val2 ;
17365 int ecode2 = 0 ;
17366 PyObject * obj0 = 0 ;
17367 PyObject * obj1 = 0 ;
17368 char * kwnames[] = {
17369 (char *) "self",(char *) "flags", NULL
17370 };
17371
17372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
17373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
17374 if (!SWIG_IsOK(res1)) {
17375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
17376 }
17377 arg1 = reinterpret_cast< wxSound * >(argp1);
17378 if (obj1) {
17379 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17380 if (!SWIG_IsOK(ecode2)) {
17381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
17382 }
17383 arg2 = static_cast< unsigned int >(val2);
17384 }
17385 {
17386 if (!wxPyCheckForApp()) SWIG_fail;
17387 PyThreadState* __tstate = wxPyBeginAllowThreads();
17388 result = (bool)((wxSound const *)arg1)->Play(arg2);
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 {
17393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17394 }
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj = 0;
17403 wxString *arg1 = 0 ;
17404 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
17405 bool result;
17406 bool temp1 = false ;
17407 unsigned int val2 ;
17408 int ecode2 = 0 ;
17409 PyObject * obj0 = 0 ;
17410 PyObject * obj1 = 0 ;
17411 char * kwnames[] = {
17412 (char *) "filename",(char *) "flags", NULL
17413 };
17414
17415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
17416 {
17417 arg1 = wxString_in_helper(obj0);
17418 if (arg1 == NULL) SWIG_fail;
17419 temp1 = true;
17420 }
17421 if (obj1) {
17422 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17423 if (!SWIG_IsOK(ecode2)) {
17424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
17425 }
17426 arg2 = static_cast< unsigned int >(val2);
17427 }
17428 {
17429 if (!wxPyCheckForApp()) SWIG_fail;
17430 PyThreadState* __tstate = wxPyBeginAllowThreads();
17431 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 {
17436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17437 }
17438 {
17439 if (temp1)
17440 delete arg1;
17441 }
17442 return resultobj;
17443 fail:
17444 {
17445 if (temp1)
17446 delete arg1;
17447 }
17448 return NULL;
17449 }
17450
17451
17452 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17453 PyObject *resultobj = 0;
17454
17455 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
17456 {
17457 if (!wxPyCheckForApp()) SWIG_fail;
17458 PyThreadState* __tstate = wxPyBeginAllowThreads();
17459 wxSound::Stop();
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 resultobj = SWIG_Py_Void();
17464 return resultobj;
17465 fail:
17466 return NULL;
17467 }
17468
17469
17470 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17471 PyObject *obj;
17472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17473 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
17474 return SWIG_Py_Void();
17475 }
17476
17477 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17478 return SWIG_Python_InitShadowInstance(args);
17479 }
17480
17481 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17482 PyObject *resultobj = 0;
17483 wxString *arg1 = 0 ;
17484 wxString *arg2 = 0 ;
17485 wxString *arg3 = 0 ;
17486 wxString *arg4 = 0 ;
17487 wxFileTypeInfo *result = 0 ;
17488 bool temp1 = false ;
17489 bool temp2 = false ;
17490 bool temp3 = false ;
17491 bool temp4 = false ;
17492 PyObject * obj0 = 0 ;
17493 PyObject * obj1 = 0 ;
17494 PyObject * obj2 = 0 ;
17495 PyObject * obj3 = 0 ;
17496 char * kwnames[] = {
17497 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
17498 };
17499
17500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17501 {
17502 arg1 = wxString_in_helper(obj0);
17503 if (arg1 == NULL) SWIG_fail;
17504 temp1 = true;
17505 }
17506 {
17507 arg2 = wxString_in_helper(obj1);
17508 if (arg2 == NULL) SWIG_fail;
17509 temp2 = true;
17510 }
17511 {
17512 arg3 = wxString_in_helper(obj2);
17513 if (arg3 == NULL) SWIG_fail;
17514 temp3 = true;
17515 }
17516 {
17517 arg4 = wxString_in_helper(obj3);
17518 if (arg4 == NULL) SWIG_fail;
17519 temp4 = true;
17520 }
17521 {
17522 PyThreadState* __tstate = wxPyBeginAllowThreads();
17523 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
17524 wxPyEndAllowThreads(__tstate);
17525 if (PyErr_Occurred()) SWIG_fail;
17526 }
17527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
17528 {
17529 if (temp1)
17530 delete arg1;
17531 }
17532 {
17533 if (temp2)
17534 delete arg2;
17535 }
17536 {
17537 if (temp3)
17538 delete arg3;
17539 }
17540 {
17541 if (temp4)
17542 delete arg4;
17543 }
17544 return resultobj;
17545 fail:
17546 {
17547 if (temp1)
17548 delete arg1;
17549 }
17550 {
17551 if (temp2)
17552 delete arg2;
17553 }
17554 {
17555 if (temp3)
17556 delete arg3;
17557 }
17558 {
17559 if (temp4)
17560 delete arg4;
17561 }
17562 return NULL;
17563 }
17564
17565
17566 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17567 PyObject *resultobj = 0;
17568 wxArrayString *arg1 = 0 ;
17569 wxFileTypeInfo *result = 0 ;
17570 bool temp1 = false ;
17571 PyObject * obj0 = 0 ;
17572 char * kwnames[] = {
17573 (char *) "sArray", NULL
17574 };
17575
17576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
17577 {
17578 if (! PySequence_Check(obj0)) {
17579 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
17580 SWIG_fail;
17581 }
17582 arg1 = new wxArrayString;
17583 temp1 = true;
17584 int i, len=PySequence_Length(obj0);
17585 for (i=0; i<len; i++) {
17586 PyObject* item = PySequence_GetItem(obj0, i);
17587 wxString* s = wxString_in_helper(item);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 arg1->Add(*s);
17590 delete s;
17591 Py_DECREF(item);
17592 }
17593 }
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
17597 wxPyEndAllowThreads(__tstate);
17598 if (PyErr_Occurred()) SWIG_fail;
17599 }
17600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17601 {
17602 if (temp1) delete arg1;
17603 }
17604 return resultobj;
17605 fail:
17606 {
17607 if (temp1) delete arg1;
17608 }
17609 return NULL;
17610 }
17611
17612
17613 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17614 PyObject *resultobj = 0;
17615 wxFileTypeInfo *result = 0 ;
17616
17617 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (wxFileTypeInfo *)new wxFileTypeInfo();
17621 wxPyEndAllowThreads(__tstate);
17622 if (PyErr_Occurred()) SWIG_fail;
17623 }
17624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
17625 return resultobj;
17626 fail:
17627 return NULL;
17628 }
17629
17630
17631 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17632 PyObject *resultobj = 0;
17633 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17634 bool result;
17635 void *argp1 = 0 ;
17636 int res1 = 0 ;
17637 PyObject *swig_obj[1] ;
17638
17639 if (!args) SWIG_fail;
17640 swig_obj[0] = args;
17641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17642 if (!SWIG_IsOK(res1)) {
17643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17644 }
17645 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17646 {
17647 PyThreadState* __tstate = wxPyBeginAllowThreads();
17648 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
17649 wxPyEndAllowThreads(__tstate);
17650 if (PyErr_Occurred()) SWIG_fail;
17651 }
17652 {
17653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17654 }
17655 return resultobj;
17656 fail:
17657 return NULL;
17658 }
17659
17660
17661 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17662 PyObject *resultobj = 0;
17663 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17664 wxString *arg2 = 0 ;
17665 int arg3 = (int) 0 ;
17666 void *argp1 = 0 ;
17667 int res1 = 0 ;
17668 bool temp2 = false ;
17669 int val3 ;
17670 int ecode3 = 0 ;
17671 PyObject * obj0 = 0 ;
17672 PyObject * obj1 = 0 ;
17673 PyObject * obj2 = 0 ;
17674 char * kwnames[] = {
17675 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
17676 };
17677
17678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17680 if (!SWIG_IsOK(res1)) {
17681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17682 }
17683 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17684 {
17685 arg2 = wxString_in_helper(obj1);
17686 if (arg2 == NULL) SWIG_fail;
17687 temp2 = true;
17688 }
17689 if (obj2) {
17690 ecode3 = SWIG_AsVal_int(obj2, &val3);
17691 if (!SWIG_IsOK(ecode3)) {
17692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
17693 }
17694 arg3 = static_cast< int >(val3);
17695 }
17696 {
17697 PyThreadState* __tstate = wxPyBeginAllowThreads();
17698 (arg1)->SetIcon((wxString const &)*arg2,arg3);
17699 wxPyEndAllowThreads(__tstate);
17700 if (PyErr_Occurred()) SWIG_fail;
17701 }
17702 resultobj = SWIG_Py_Void();
17703 {
17704 if (temp2)
17705 delete arg2;
17706 }
17707 return resultobj;
17708 fail:
17709 {
17710 if (temp2)
17711 delete arg2;
17712 }
17713 return NULL;
17714 }
17715
17716
17717 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17718 PyObject *resultobj = 0;
17719 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17720 wxString *arg2 = 0 ;
17721 void *argp1 = 0 ;
17722 int res1 = 0 ;
17723 bool temp2 = false ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 char * kwnames[] = {
17727 (char *) "self",(char *) "shortDesc", NULL
17728 };
17729
17730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
17731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17732 if (!SWIG_IsOK(res1)) {
17733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
17734 }
17735 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17736 {
17737 arg2 = wxString_in_helper(obj1);
17738 if (arg2 == NULL) SWIG_fail;
17739 temp2 = true;
17740 }
17741 {
17742 PyThreadState* __tstate = wxPyBeginAllowThreads();
17743 (arg1)->SetShortDesc((wxString const &)*arg2);
17744 wxPyEndAllowThreads(__tstate);
17745 if (PyErr_Occurred()) SWIG_fail;
17746 }
17747 resultobj = SWIG_Py_Void();
17748 {
17749 if (temp2)
17750 delete arg2;
17751 }
17752 return resultobj;
17753 fail:
17754 {
17755 if (temp2)
17756 delete arg2;
17757 }
17758 return NULL;
17759 }
17760
17761
17762 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17763 PyObject *resultobj = 0;
17764 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17765 wxString *result = 0 ;
17766 void *argp1 = 0 ;
17767 int res1 = 0 ;
17768 PyObject *swig_obj[1] ;
17769
17770 if (!args) SWIG_fail;
17771 swig_obj[0] = args;
17772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17773 if (!SWIG_IsOK(res1)) {
17774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17775 }
17776 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 {
17780 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
17781 result = (wxString *) &_result_ref;
17782 }
17783 wxPyEndAllowThreads(__tstate);
17784 if (PyErr_Occurred()) SWIG_fail;
17785 }
17786 {
17787 #if wxUSE_UNICODE
17788 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17789 #else
17790 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17791 #endif
17792 }
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17800 PyObject *resultobj = 0;
17801 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17802 wxString *result = 0 ;
17803 void *argp1 = 0 ;
17804 int res1 = 0 ;
17805 PyObject *swig_obj[1] ;
17806
17807 if (!args) SWIG_fail;
17808 swig_obj[0] = args;
17809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17810 if (!SWIG_IsOK(res1)) {
17811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17812 }
17813 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 {
17817 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
17818 result = (wxString *) &_result_ref;
17819 }
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 {
17824 #if wxUSE_UNICODE
17825 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17826 #else
17827 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17828 #endif
17829 }
17830 return resultobj;
17831 fail:
17832 return NULL;
17833 }
17834
17835
17836 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17837 PyObject *resultobj = 0;
17838 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17839 wxString *result = 0 ;
17840 void *argp1 = 0 ;
17841 int res1 = 0 ;
17842 PyObject *swig_obj[1] ;
17843
17844 if (!args) SWIG_fail;
17845 swig_obj[0] = args;
17846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17847 if (!SWIG_IsOK(res1)) {
17848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17849 }
17850 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17851 {
17852 PyThreadState* __tstate = wxPyBeginAllowThreads();
17853 {
17854 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
17855 result = (wxString *) &_result_ref;
17856 }
17857 wxPyEndAllowThreads(__tstate);
17858 if (PyErr_Occurred()) SWIG_fail;
17859 }
17860 {
17861 #if wxUSE_UNICODE
17862 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17863 #else
17864 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17865 #endif
17866 }
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17874 PyObject *resultobj = 0;
17875 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17876 wxString *result = 0 ;
17877 void *argp1 = 0 ;
17878 int res1 = 0 ;
17879 PyObject *swig_obj[1] ;
17880
17881 if (!args) SWIG_fail;
17882 swig_obj[0] = args;
17883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17884 if (!SWIG_IsOK(res1)) {
17885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17886 }
17887 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 {
17891 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
17892 result = (wxString *) &_result_ref;
17893 }
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 {
17898 #if wxUSE_UNICODE
17899 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17900 #else
17901 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17902 #endif
17903 }
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17911 PyObject *resultobj = 0;
17912 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17913 wxString *result = 0 ;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 PyObject *swig_obj[1] ;
17917
17918 if (!args) SWIG_fail;
17919 swig_obj[0] = args;
17920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17921 if (!SWIG_IsOK(res1)) {
17922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17923 }
17924 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17925 {
17926 PyThreadState* __tstate = wxPyBeginAllowThreads();
17927 {
17928 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
17929 result = (wxString *) &_result_ref;
17930 }
17931 wxPyEndAllowThreads(__tstate);
17932 if (PyErr_Occurred()) SWIG_fail;
17933 }
17934 {
17935 #if wxUSE_UNICODE
17936 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17937 #else
17938 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17939 #endif
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17948 PyObject *resultobj = 0;
17949 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17950 wxArrayString *result = 0 ;
17951 void *argp1 = 0 ;
17952 int res1 = 0 ;
17953 PyObject *swig_obj[1] ;
17954
17955 if (!args) SWIG_fail;
17956 swig_obj[0] = args;
17957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17958 if (!SWIG_IsOK(res1)) {
17959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17960 }
17961 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 {
17965 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
17966 result = (wxArrayString *) &_result_ref;
17967 }
17968 wxPyEndAllowThreads(__tstate);
17969 if (PyErr_Occurred()) SWIG_fail;
17970 }
17971 {
17972 resultobj = wxArrayString2PyList_helper(*result);
17973 }
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17981 PyObject *resultobj = 0;
17982 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
17983 size_t result;
17984 void *argp1 = 0 ;
17985 int res1 = 0 ;
17986 PyObject *swig_obj[1] ;
17987
17988 if (!args) SWIG_fail;
17989 swig_obj[0] = args;
17990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
17991 if (!SWIG_IsOK(res1)) {
17992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
17993 }
17994 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
17995 {
17996 PyThreadState* __tstate = wxPyBeginAllowThreads();
17997 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
17998 wxPyEndAllowThreads(__tstate);
17999 if (PyErr_Occurred()) SWIG_fail;
18000 }
18001 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18009 PyObject *resultobj = 0;
18010 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18011 wxString *result = 0 ;
18012 void *argp1 = 0 ;
18013 int res1 = 0 ;
18014 PyObject *swig_obj[1] ;
18015
18016 if (!args) SWIG_fail;
18017 swig_obj[0] = args;
18018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18019 if (!SWIG_IsOK(res1)) {
18020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18021 }
18022 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18023 {
18024 PyThreadState* __tstate = wxPyBeginAllowThreads();
18025 {
18026 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
18027 result = (wxString *) &_result_ref;
18028 }
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 {
18033 #if wxUSE_UNICODE
18034 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18035 #else
18036 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18037 #endif
18038 }
18039 return resultobj;
18040 fail:
18041 return NULL;
18042 }
18043
18044
18045 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18046 PyObject *resultobj = 0;
18047 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
18048 int result;
18049 void *argp1 = 0 ;
18050 int res1 = 0 ;
18051 PyObject *swig_obj[1] ;
18052
18053 if (!args) SWIG_fail;
18054 swig_obj[0] = args;
18055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
18056 if (!SWIG_IsOK(res1)) {
18057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
18058 }
18059 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18060 {
18061 PyThreadState* __tstate = wxPyBeginAllowThreads();
18062 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
18063 wxPyEndAllowThreads(__tstate);
18064 if (PyErr_Occurred()) SWIG_fail;
18065 }
18066 resultobj = SWIG_From_int(static_cast< int >(result));
18067 return resultobj;
18068 fail:
18069 return NULL;
18070 }
18071
18072
18073 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18074 PyObject *obj;
18075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18076 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
18077 return SWIG_Py_Void();
18078 }
18079
18080 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18081 return SWIG_Python_InitShadowInstance(args);
18082 }
18083
18084 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18085 PyObject *resultobj = 0;
18086 wxFileTypeInfo *arg1 = 0 ;
18087 wxFileType *result = 0 ;
18088 void *argp1 = 0 ;
18089 int res1 = 0 ;
18090 PyObject * obj0 = 0 ;
18091 char * kwnames[] = {
18092 (char *) "ftInfo", NULL
18093 };
18094
18095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
18096 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18097 if (!SWIG_IsOK(res1)) {
18098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18099 }
18100 if (!argp1) {
18101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
18102 }
18103 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
18104 {
18105 PyThreadState* __tstate = wxPyBeginAllowThreads();
18106 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
18107 wxPyEndAllowThreads(__tstate);
18108 if (PyErr_Occurred()) SWIG_fail;
18109 }
18110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
18111 return resultobj;
18112 fail:
18113 return NULL;
18114 }
18115
18116
18117 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18118 PyObject *resultobj = 0;
18119 wxFileType *arg1 = (wxFileType *) 0 ;
18120 void *argp1 = 0 ;
18121 int res1 = 0 ;
18122 PyObject *swig_obj[1] ;
18123
18124 if (!args) SWIG_fail;
18125 swig_obj[0] = args;
18126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
18127 if (!SWIG_IsOK(res1)) {
18128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
18129 }
18130 arg1 = reinterpret_cast< wxFileType * >(argp1);
18131 {
18132 PyThreadState* __tstate = wxPyBeginAllowThreads();
18133 delete arg1;
18134
18135 wxPyEndAllowThreads(__tstate);
18136 if (PyErr_Occurred()) SWIG_fail;
18137 }
18138 resultobj = SWIG_Py_Void();
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18146 PyObject *resultobj = 0;
18147 wxFileType *arg1 = (wxFileType *) 0 ;
18148 PyObject *result = 0 ;
18149 void *argp1 = 0 ;
18150 int res1 = 0 ;
18151 PyObject *swig_obj[1] ;
18152
18153 if (!args) SWIG_fail;
18154 swig_obj[0] = args;
18155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18156 if (!SWIG_IsOK(res1)) {
18157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
18158 }
18159 arg1 = reinterpret_cast< wxFileType * >(argp1);
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (PyObject *)wxFileType_GetMimeType(arg1);
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 resultobj = result;
18167 return resultobj;
18168 fail:
18169 return NULL;
18170 }
18171
18172
18173 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18174 PyObject *resultobj = 0;
18175 wxFileType *arg1 = (wxFileType *) 0 ;
18176 PyObject *result = 0 ;
18177 void *argp1 = 0 ;
18178 int res1 = 0 ;
18179 PyObject *swig_obj[1] ;
18180
18181 if (!args) SWIG_fail;
18182 swig_obj[0] = args;
18183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18184 if (!SWIG_IsOK(res1)) {
18185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
18186 }
18187 arg1 = reinterpret_cast< wxFileType * >(argp1);
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
18191 wxPyEndAllowThreads(__tstate);
18192 if (PyErr_Occurred()) SWIG_fail;
18193 }
18194 resultobj = result;
18195 return resultobj;
18196 fail:
18197 return NULL;
18198 }
18199
18200
18201 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18202 PyObject *resultobj = 0;
18203 wxFileType *arg1 = (wxFileType *) 0 ;
18204 PyObject *result = 0 ;
18205 void *argp1 = 0 ;
18206 int res1 = 0 ;
18207 PyObject *swig_obj[1] ;
18208
18209 if (!args) SWIG_fail;
18210 swig_obj[0] = args;
18211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18212 if (!SWIG_IsOK(res1)) {
18213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
18214 }
18215 arg1 = reinterpret_cast< wxFileType * >(argp1);
18216 {
18217 PyThreadState* __tstate = wxPyBeginAllowThreads();
18218 result = (PyObject *)wxFileType_GetExtensions(arg1);
18219 wxPyEndAllowThreads(__tstate);
18220 if (PyErr_Occurred()) SWIG_fail;
18221 }
18222 resultobj = result;
18223 return resultobj;
18224 fail:
18225 return NULL;
18226 }
18227
18228
18229 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18230 PyObject *resultobj = 0;
18231 wxFileType *arg1 = (wxFileType *) 0 ;
18232 wxIcon *result = 0 ;
18233 void *argp1 = 0 ;
18234 int res1 = 0 ;
18235 PyObject *swig_obj[1] ;
18236
18237 if (!args) SWIG_fail;
18238 swig_obj[0] = args;
18239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18240 if (!SWIG_IsOK(res1)) {
18241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18242 }
18243 arg1 = reinterpret_cast< wxFileType * >(argp1);
18244 {
18245 PyThreadState* __tstate = wxPyBeginAllowThreads();
18246 result = (wxIcon *)wxFileType_GetIcon(arg1);
18247 wxPyEndAllowThreads(__tstate);
18248 if (PyErr_Occurred()) SWIG_fail;
18249 }
18250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
18251 return resultobj;
18252 fail:
18253 return NULL;
18254 }
18255
18256
18257 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18258 PyObject *resultobj = 0;
18259 wxFileType *arg1 = (wxFileType *) 0 ;
18260 PyObject *result = 0 ;
18261 void *argp1 = 0 ;
18262 int res1 = 0 ;
18263 PyObject *swig_obj[1] ;
18264
18265 if (!args) SWIG_fail;
18266 swig_obj[0] = args;
18267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18268 if (!SWIG_IsOK(res1)) {
18269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
18270 }
18271 arg1 = reinterpret_cast< wxFileType * >(argp1);
18272 {
18273 PyThreadState* __tstate = wxPyBeginAllowThreads();
18274 result = (PyObject *)wxFileType_GetIconInfo(arg1);
18275 wxPyEndAllowThreads(__tstate);
18276 if (PyErr_Occurred()) SWIG_fail;
18277 }
18278 resultobj = result;
18279 return resultobj;
18280 fail:
18281 return NULL;
18282 }
18283
18284
18285 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18286 PyObject *resultobj = 0;
18287 wxFileType *arg1 = (wxFileType *) 0 ;
18288 PyObject *result = 0 ;
18289 void *argp1 = 0 ;
18290 int res1 = 0 ;
18291 PyObject *swig_obj[1] ;
18292
18293 if (!args) SWIG_fail;
18294 swig_obj[0] = args;
18295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18296 if (!SWIG_IsOK(res1)) {
18297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
18298 }
18299 arg1 = reinterpret_cast< wxFileType * >(argp1);
18300 {
18301 PyThreadState* __tstate = wxPyBeginAllowThreads();
18302 result = (PyObject *)wxFileType_GetDescription(arg1);
18303 wxPyEndAllowThreads(__tstate);
18304 if (PyErr_Occurred()) SWIG_fail;
18305 }
18306 resultobj = result;
18307 return resultobj;
18308 fail:
18309 return NULL;
18310 }
18311
18312
18313 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18314 PyObject *resultobj = 0;
18315 wxFileType *arg1 = (wxFileType *) 0 ;
18316 wxString *arg2 = 0 ;
18317 wxString const &arg3_defvalue = wxPyEmptyString ;
18318 wxString *arg3 = (wxString *) &arg3_defvalue ;
18319 PyObject *result = 0 ;
18320 void *argp1 = 0 ;
18321 int res1 = 0 ;
18322 bool temp2 = false ;
18323 bool temp3 = false ;
18324 PyObject * obj0 = 0 ;
18325 PyObject * obj1 = 0 ;
18326 PyObject * obj2 = 0 ;
18327 char * kwnames[] = {
18328 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18329 };
18330
18331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18333 if (!SWIG_IsOK(res1)) {
18334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18335 }
18336 arg1 = reinterpret_cast< wxFileType * >(argp1);
18337 {
18338 arg2 = wxString_in_helper(obj1);
18339 if (arg2 == NULL) SWIG_fail;
18340 temp2 = true;
18341 }
18342 if (obj2) {
18343 {
18344 arg3 = wxString_in_helper(obj2);
18345 if (arg3 == NULL) SWIG_fail;
18346 temp3 = true;
18347 }
18348 }
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = result;
18356 {
18357 if (temp2)
18358 delete arg2;
18359 }
18360 {
18361 if (temp3)
18362 delete arg3;
18363 }
18364 return resultobj;
18365 fail:
18366 {
18367 if (temp2)
18368 delete arg2;
18369 }
18370 {
18371 if (temp3)
18372 delete arg3;
18373 }
18374 return NULL;
18375 }
18376
18377
18378 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj = 0;
18380 wxFileType *arg1 = (wxFileType *) 0 ;
18381 wxString *arg2 = 0 ;
18382 wxString const &arg3_defvalue = wxPyEmptyString ;
18383 wxString *arg3 = (wxString *) &arg3_defvalue ;
18384 PyObject *result = 0 ;
18385 void *argp1 = 0 ;
18386 int res1 = 0 ;
18387 bool temp2 = false ;
18388 bool temp3 = false ;
18389 PyObject * obj0 = 0 ;
18390 PyObject * obj1 = 0 ;
18391 PyObject * obj2 = 0 ;
18392 char * kwnames[] = {
18393 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18394 };
18395
18396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18398 if (!SWIG_IsOK(res1)) {
18399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18400 }
18401 arg1 = reinterpret_cast< wxFileType * >(argp1);
18402 {
18403 arg2 = wxString_in_helper(obj1);
18404 if (arg2 == NULL) SWIG_fail;
18405 temp2 = true;
18406 }
18407 if (obj2) {
18408 {
18409 arg3 = wxString_in_helper(obj2);
18410 if (arg3 == NULL) SWIG_fail;
18411 temp3 = true;
18412 }
18413 }
18414 {
18415 PyThreadState* __tstate = wxPyBeginAllowThreads();
18416 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18417 wxPyEndAllowThreads(__tstate);
18418 if (PyErr_Occurred()) SWIG_fail;
18419 }
18420 resultobj = result;
18421 {
18422 if (temp2)
18423 delete arg2;
18424 }
18425 {
18426 if (temp3)
18427 delete arg3;
18428 }
18429 return resultobj;
18430 fail:
18431 {
18432 if (temp2)
18433 delete arg2;
18434 }
18435 {
18436 if (temp3)
18437 delete arg3;
18438 }
18439 return NULL;
18440 }
18441
18442
18443 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18444 PyObject *resultobj = 0;
18445 wxFileType *arg1 = (wxFileType *) 0 ;
18446 wxString *arg2 = 0 ;
18447 wxString const &arg3_defvalue = wxPyEmptyString ;
18448 wxString *arg3 = (wxString *) &arg3_defvalue ;
18449 PyObject *result = 0 ;
18450 void *argp1 = 0 ;
18451 int res1 = 0 ;
18452 bool temp2 = false ;
18453 bool temp3 = false ;
18454 PyObject * obj0 = 0 ;
18455 PyObject * obj1 = 0 ;
18456 PyObject * obj2 = 0 ;
18457 char * kwnames[] = {
18458 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
18459 };
18460
18461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18463 if (!SWIG_IsOK(res1)) {
18464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
18465 }
18466 arg1 = reinterpret_cast< wxFileType * >(argp1);
18467 {
18468 arg2 = wxString_in_helper(obj1);
18469 if (arg2 == NULL) SWIG_fail;
18470 temp2 = true;
18471 }
18472 if (obj2) {
18473 {
18474 arg3 = wxString_in_helper(obj2);
18475 if (arg3 == NULL) SWIG_fail;
18476 temp3 = true;
18477 }
18478 }
18479 {
18480 PyThreadState* __tstate = wxPyBeginAllowThreads();
18481 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 resultobj = result;
18486 {
18487 if (temp2)
18488 delete arg2;
18489 }
18490 {
18491 if (temp3)
18492 delete arg3;
18493 }
18494 return resultobj;
18495 fail:
18496 {
18497 if (temp2)
18498 delete arg2;
18499 }
18500 {
18501 if (temp3)
18502 delete arg3;
18503 }
18504 return NULL;
18505 }
18506
18507
18508 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18509 PyObject *resultobj = 0;
18510 wxFileType *arg1 = (wxFileType *) 0 ;
18511 wxString *arg2 = 0 ;
18512 wxString *arg3 = 0 ;
18513 bool arg4 = (bool) true ;
18514 bool result;
18515 void *argp1 = 0 ;
18516 int res1 = 0 ;
18517 bool temp2 = false ;
18518 bool temp3 = false ;
18519 bool val4 ;
18520 int ecode4 = 0 ;
18521 PyObject * obj0 = 0 ;
18522 PyObject * obj1 = 0 ;
18523 PyObject * obj2 = 0 ;
18524 PyObject * obj3 = 0 ;
18525 char * kwnames[] = {
18526 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
18527 };
18528
18529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18531 if (!SWIG_IsOK(res1)) {
18532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
18533 }
18534 arg1 = reinterpret_cast< wxFileType * >(argp1);
18535 {
18536 arg2 = wxString_in_helper(obj1);
18537 if (arg2 == NULL) SWIG_fail;
18538 temp2 = true;
18539 }
18540 {
18541 arg3 = wxString_in_helper(obj2);
18542 if (arg3 == NULL) SWIG_fail;
18543 temp3 = true;
18544 }
18545 if (obj3) {
18546 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18547 if (!SWIG_IsOK(ecode4)) {
18548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
18549 }
18550 arg4 = static_cast< bool >(val4);
18551 }
18552 {
18553 PyThreadState* __tstate = wxPyBeginAllowThreads();
18554 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18555 wxPyEndAllowThreads(__tstate);
18556 if (PyErr_Occurred()) SWIG_fail;
18557 }
18558 {
18559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18560 }
18561 {
18562 if (temp2)
18563 delete arg2;
18564 }
18565 {
18566 if (temp3)
18567 delete arg3;
18568 }
18569 return resultobj;
18570 fail:
18571 {
18572 if (temp2)
18573 delete arg2;
18574 }
18575 {
18576 if (temp3)
18577 delete arg3;
18578 }
18579 return NULL;
18580 }
18581
18582
18583 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18584 PyObject *resultobj = 0;
18585 wxFileType *arg1 = (wxFileType *) 0 ;
18586 wxString const &arg2_defvalue = wxPyEmptyString ;
18587 wxString *arg2 = (wxString *) &arg2_defvalue ;
18588 int arg3 = (int) 0 ;
18589 bool result;
18590 void *argp1 = 0 ;
18591 int res1 = 0 ;
18592 bool temp2 = false ;
18593 int val3 ;
18594 int ecode3 = 0 ;
18595 PyObject * obj0 = 0 ;
18596 PyObject * obj1 = 0 ;
18597 PyObject * obj2 = 0 ;
18598 char * kwnames[] = {
18599 (char *) "self",(char *) "cmd",(char *) "index", NULL
18600 };
18601
18602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18604 if (!SWIG_IsOK(res1)) {
18605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
18606 }
18607 arg1 = reinterpret_cast< wxFileType * >(argp1);
18608 if (obj1) {
18609 {
18610 arg2 = wxString_in_helper(obj1);
18611 if (arg2 == NULL) SWIG_fail;
18612 temp2 = true;
18613 }
18614 }
18615 if (obj2) {
18616 ecode3 = SWIG_AsVal_int(obj2, &val3);
18617 if (!SWIG_IsOK(ecode3)) {
18618 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
18619 }
18620 arg3 = static_cast< int >(val3);
18621 }
18622 {
18623 PyThreadState* __tstate = wxPyBeginAllowThreads();
18624 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
18625 wxPyEndAllowThreads(__tstate);
18626 if (PyErr_Occurred()) SWIG_fail;
18627 }
18628 {
18629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18630 }
18631 {
18632 if (temp2)
18633 delete arg2;
18634 }
18635 return resultobj;
18636 fail:
18637 {
18638 if (temp2)
18639 delete arg2;
18640 }
18641 return NULL;
18642 }
18643
18644
18645 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18646 PyObject *resultobj = 0;
18647 wxFileType *arg1 = (wxFileType *) 0 ;
18648 bool result;
18649 void *argp1 = 0 ;
18650 int res1 = 0 ;
18651 PyObject *swig_obj[1] ;
18652
18653 if (!args) SWIG_fail;
18654 swig_obj[0] = args;
18655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
18656 if (!SWIG_IsOK(res1)) {
18657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
18658 }
18659 arg1 = reinterpret_cast< wxFileType * >(argp1);
18660 {
18661 PyThreadState* __tstate = wxPyBeginAllowThreads();
18662 result = (bool)(arg1)->Unassociate();
18663 wxPyEndAllowThreads(__tstate);
18664 if (PyErr_Occurred()) SWIG_fail;
18665 }
18666 {
18667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18668 }
18669 return resultobj;
18670 fail:
18671 return NULL;
18672 }
18673
18674
18675 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18676 PyObject *resultobj = 0;
18677 wxString *arg1 = 0 ;
18678 wxString *arg2 = 0 ;
18679 wxString const &arg3_defvalue = wxPyEmptyString ;
18680 wxString *arg3 = (wxString *) &arg3_defvalue ;
18681 wxString result;
18682 bool temp1 = false ;
18683 bool temp2 = false ;
18684 bool temp3 = false ;
18685 PyObject * obj0 = 0 ;
18686 PyObject * obj1 = 0 ;
18687 PyObject * obj2 = 0 ;
18688 char * kwnames[] = {
18689 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
18690 };
18691
18692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18693 {
18694 arg1 = wxString_in_helper(obj0);
18695 if (arg1 == NULL) SWIG_fail;
18696 temp1 = true;
18697 }
18698 {
18699 arg2 = wxString_in_helper(obj1);
18700 if (arg2 == NULL) SWIG_fail;
18701 temp2 = true;
18702 }
18703 if (obj2) {
18704 {
18705 arg3 = wxString_in_helper(obj2);
18706 if (arg3 == NULL) SWIG_fail;
18707 temp3 = true;
18708 }
18709 }
18710 {
18711 PyThreadState* __tstate = wxPyBeginAllowThreads();
18712 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
18713 wxPyEndAllowThreads(__tstate);
18714 if (PyErr_Occurred()) SWIG_fail;
18715 }
18716 {
18717 #if wxUSE_UNICODE
18718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18719 #else
18720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18721 #endif
18722 }
18723 {
18724 if (temp1)
18725 delete arg1;
18726 }
18727 {
18728 if (temp2)
18729 delete arg2;
18730 }
18731 {
18732 if (temp3)
18733 delete arg3;
18734 }
18735 return resultobj;
18736 fail:
18737 {
18738 if (temp1)
18739 delete arg1;
18740 }
18741 {
18742 if (temp2)
18743 delete arg2;
18744 }
18745 {
18746 if (temp3)
18747 delete arg3;
18748 }
18749 return NULL;
18750 }
18751
18752
18753 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18754 PyObject *obj;
18755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18756 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
18757 return SWIG_Py_Void();
18758 }
18759
18760 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18761 return SWIG_Python_InitShadowInstance(args);
18762 }
18763
18764 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
18765 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
18766 return 1;
18767 }
18768
18769
18770 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
18771 PyObject *pyobj = 0;
18772
18773 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
18774 return pyobj;
18775 }
18776
18777
18778 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj = 0;
18780 wxString *arg1 = 0 ;
18781 wxString *arg2 = 0 ;
18782 bool result;
18783 bool temp1 = false ;
18784 bool temp2 = false ;
18785 PyObject * obj0 = 0 ;
18786 PyObject * obj1 = 0 ;
18787 char * kwnames[] = {
18788 (char *) "mimeType",(char *) "wildcard", NULL
18789 };
18790
18791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
18792 {
18793 arg1 = wxString_in_helper(obj0);
18794 if (arg1 == NULL) SWIG_fail;
18795 temp1 = true;
18796 }
18797 {
18798 arg2 = wxString_in_helper(obj1);
18799 if (arg2 == NULL) SWIG_fail;
18800 temp2 = true;
18801 }
18802 {
18803 PyThreadState* __tstate = wxPyBeginAllowThreads();
18804 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
18805 wxPyEndAllowThreads(__tstate);
18806 if (PyErr_Occurred()) SWIG_fail;
18807 }
18808 {
18809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18810 }
18811 {
18812 if (temp1)
18813 delete arg1;
18814 }
18815 {
18816 if (temp2)
18817 delete arg2;
18818 }
18819 return resultobj;
18820 fail:
18821 {
18822 if (temp1)
18823 delete arg1;
18824 }
18825 {
18826 if (temp2)
18827 delete arg2;
18828 }
18829 return NULL;
18830 }
18831
18832
18833 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18834 PyObject *resultobj = 0;
18835 wxMimeTypesManager *result = 0 ;
18836
18837 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
18838 {
18839 PyThreadState* __tstate = wxPyBeginAllowThreads();
18840 result = (wxMimeTypesManager *)new wxMimeTypesManager();
18841 wxPyEndAllowThreads(__tstate);
18842 if (PyErr_Occurred()) SWIG_fail;
18843 }
18844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj = 0;
18853 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18854 int arg2 = (int) wxMAILCAP_ALL ;
18855 wxString const &arg3_defvalue = wxPyEmptyString ;
18856 wxString *arg3 = (wxString *) &arg3_defvalue ;
18857 void *argp1 = 0 ;
18858 int res1 = 0 ;
18859 int val2 ;
18860 int ecode2 = 0 ;
18861 bool temp3 = false ;
18862 PyObject * obj0 = 0 ;
18863 PyObject * obj1 = 0 ;
18864 PyObject * obj2 = 0 ;
18865 char * kwnames[] = {
18866 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
18867 };
18868
18869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18871 if (!SWIG_IsOK(res1)) {
18872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18873 }
18874 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18875 if (obj1) {
18876 ecode2 = SWIG_AsVal_int(obj1, &val2);
18877 if (!SWIG_IsOK(ecode2)) {
18878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
18879 }
18880 arg2 = static_cast< int >(val2);
18881 }
18882 if (obj2) {
18883 {
18884 arg3 = wxString_in_helper(obj2);
18885 if (arg3 == NULL) SWIG_fail;
18886 temp3 = true;
18887 }
18888 }
18889 {
18890 PyThreadState* __tstate = wxPyBeginAllowThreads();
18891 (arg1)->Initialize(arg2,(wxString const &)*arg3);
18892 wxPyEndAllowThreads(__tstate);
18893 if (PyErr_Occurred()) SWIG_fail;
18894 }
18895 resultobj = SWIG_Py_Void();
18896 {
18897 if (temp3)
18898 delete arg3;
18899 }
18900 return resultobj;
18901 fail:
18902 {
18903 if (temp3)
18904 delete arg3;
18905 }
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18911 PyObject *resultobj = 0;
18912 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18913 void *argp1 = 0 ;
18914 int res1 = 0 ;
18915 PyObject *swig_obj[1] ;
18916
18917 if (!args) SWIG_fail;
18918 swig_obj[0] = args;
18919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18920 if (!SWIG_IsOK(res1)) {
18921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18922 }
18923 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18924 {
18925 PyThreadState* __tstate = wxPyBeginAllowThreads();
18926 (arg1)->ClearData();
18927 wxPyEndAllowThreads(__tstate);
18928 if (PyErr_Occurred()) SWIG_fail;
18929 }
18930 resultobj = SWIG_Py_Void();
18931 return resultobj;
18932 fail:
18933 return NULL;
18934 }
18935
18936
18937 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18938 PyObject *resultobj = 0;
18939 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18940 wxString *arg2 = 0 ;
18941 wxFileType *result = 0 ;
18942 void *argp1 = 0 ;
18943 int res1 = 0 ;
18944 bool temp2 = false ;
18945 PyObject * obj0 = 0 ;
18946 PyObject * obj1 = 0 ;
18947 char * kwnames[] = {
18948 (char *) "self",(char *) "ext", NULL
18949 };
18950
18951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
18952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18953 if (!SWIG_IsOK(res1)) {
18954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18955 }
18956 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18957 {
18958 arg2 = wxString_in_helper(obj1);
18959 if (arg2 == NULL) SWIG_fail;
18960 temp2 = true;
18961 }
18962 {
18963 PyThreadState* __tstate = wxPyBeginAllowThreads();
18964 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
18965 wxPyEndAllowThreads(__tstate);
18966 if (PyErr_Occurred()) SWIG_fail;
18967 }
18968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18969 {
18970 if (temp2)
18971 delete arg2;
18972 }
18973 return resultobj;
18974 fail:
18975 {
18976 if (temp2)
18977 delete arg2;
18978 }
18979 return NULL;
18980 }
18981
18982
18983 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18984 PyObject *resultobj = 0;
18985 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18986 wxString *arg2 = 0 ;
18987 wxFileType *result = 0 ;
18988 void *argp1 = 0 ;
18989 int res1 = 0 ;
18990 bool temp2 = false ;
18991 PyObject * obj0 = 0 ;
18992 PyObject * obj1 = 0 ;
18993 char * kwnames[] = {
18994 (char *) "self",(char *) "mimeType", NULL
18995 };
18996
18997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
18998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18999 if (!SWIG_IsOK(res1)) {
19000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19001 }
19002 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19003 {
19004 arg2 = wxString_in_helper(obj1);
19005 if (arg2 == NULL) SWIG_fail;
19006 temp2 = true;
19007 }
19008 {
19009 PyThreadState* __tstate = wxPyBeginAllowThreads();
19010 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
19011 wxPyEndAllowThreads(__tstate);
19012 if (PyErr_Occurred()) SWIG_fail;
19013 }
19014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19015 {
19016 if (temp2)
19017 delete arg2;
19018 }
19019 return resultobj;
19020 fail:
19021 {
19022 if (temp2)
19023 delete arg2;
19024 }
19025 return NULL;
19026 }
19027
19028
19029 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19030 PyObject *resultobj = 0;
19031 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19032 wxString *arg2 = 0 ;
19033 bool arg3 = (bool) false ;
19034 bool result;
19035 void *argp1 = 0 ;
19036 int res1 = 0 ;
19037 bool temp2 = false ;
19038 bool val3 ;
19039 int ecode3 = 0 ;
19040 PyObject * obj0 = 0 ;
19041 PyObject * obj1 = 0 ;
19042 PyObject * obj2 = 0 ;
19043 char * kwnames[] = {
19044 (char *) "self",(char *) "filename",(char *) "fallback", NULL
19045 };
19046
19047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19049 if (!SWIG_IsOK(res1)) {
19050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19051 }
19052 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19053 {
19054 arg2 = wxString_in_helper(obj1);
19055 if (arg2 == NULL) SWIG_fail;
19056 temp2 = true;
19057 }
19058 if (obj2) {
19059 ecode3 = SWIG_AsVal_bool(obj2, &val3);
19060 if (!SWIG_IsOK(ecode3)) {
19061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
19062 }
19063 arg3 = static_cast< bool >(val3);
19064 }
19065 {
19066 PyThreadState* __tstate = wxPyBeginAllowThreads();
19067 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
19068 wxPyEndAllowThreads(__tstate);
19069 if (PyErr_Occurred()) SWIG_fail;
19070 }
19071 {
19072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19073 }
19074 {
19075 if (temp2)
19076 delete arg2;
19077 }
19078 return resultobj;
19079 fail:
19080 {
19081 if (temp2)
19082 delete arg2;
19083 }
19084 return NULL;
19085 }
19086
19087
19088 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19089 PyObject *resultobj = 0;
19090 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19091 wxString *arg2 = 0 ;
19092 bool result;
19093 void *argp1 = 0 ;
19094 int res1 = 0 ;
19095 bool temp2 = false ;
19096 PyObject * obj0 = 0 ;
19097 PyObject * obj1 = 0 ;
19098 char * kwnames[] = {
19099 (char *) "self",(char *) "filename", NULL
19100 };
19101
19102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
19103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19104 if (!SWIG_IsOK(res1)) {
19105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19106 }
19107 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19108 {
19109 arg2 = wxString_in_helper(obj1);
19110 if (arg2 == NULL) SWIG_fail;
19111 temp2 = true;
19112 }
19113 {
19114 PyThreadState* __tstate = wxPyBeginAllowThreads();
19115 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
19116 wxPyEndAllowThreads(__tstate);
19117 if (PyErr_Occurred()) SWIG_fail;
19118 }
19119 {
19120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19121 }
19122 {
19123 if (temp2)
19124 delete arg2;
19125 }
19126 return resultobj;
19127 fail:
19128 {
19129 if (temp2)
19130 delete arg2;
19131 }
19132 return NULL;
19133 }
19134
19135
19136 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19137 PyObject *resultobj = 0;
19138 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19139 PyObject *result = 0 ;
19140 void *argp1 = 0 ;
19141 int res1 = 0 ;
19142 PyObject *swig_obj[1] ;
19143
19144 if (!args) SWIG_fail;
19145 swig_obj[0] = args;
19146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19147 if (!SWIG_IsOK(res1)) {
19148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19149 }
19150 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19151 {
19152 PyThreadState* __tstate = wxPyBeginAllowThreads();
19153 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
19154 wxPyEndAllowThreads(__tstate);
19155 if (PyErr_Occurred()) SWIG_fail;
19156 }
19157 resultobj = result;
19158 return resultobj;
19159 fail:
19160 return NULL;
19161 }
19162
19163
19164 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19165 PyObject *resultobj = 0;
19166 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19167 wxFileTypeInfo *arg2 = 0 ;
19168 void *argp1 = 0 ;
19169 int res1 = 0 ;
19170 void *argp2 = 0 ;
19171 int res2 = 0 ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 char * kwnames[] = {
19175 (char *) "self",(char *) "ft", NULL
19176 };
19177
19178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
19179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19180 if (!SWIG_IsOK(res1)) {
19181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19182 }
19183 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19184 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19185 if (!SWIG_IsOK(res2)) {
19186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19187 }
19188 if (!argp2) {
19189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19190 }
19191 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 resultobj = SWIG_Py_Void();
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19206 PyObject *resultobj = 0;
19207 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19208 wxFileTypeInfo *arg2 = 0 ;
19209 wxFileType *result = 0 ;
19210 void *argp1 = 0 ;
19211 int res1 = 0 ;
19212 void *argp2 = 0 ;
19213 int res2 = 0 ;
19214 PyObject * obj0 = 0 ;
19215 PyObject * obj1 = 0 ;
19216 char * kwnames[] = {
19217 (char *) "self",(char *) "ftInfo", NULL
19218 };
19219
19220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
19221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19222 if (!SWIG_IsOK(res1)) {
19223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19224 }
19225 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19226 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
19227 if (!SWIG_IsOK(res2)) {
19228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19229 }
19230 if (!argp2) {
19231 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
19232 }
19233 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
19234 {
19235 PyThreadState* __tstate = wxPyBeginAllowThreads();
19236 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
19241 return resultobj;
19242 fail:
19243 return NULL;
19244 }
19245
19246
19247 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19248 PyObject *resultobj = 0;
19249 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19250 wxFileType *arg2 = (wxFileType *) 0 ;
19251 bool result;
19252 void *argp1 = 0 ;
19253 int res1 = 0 ;
19254 void *argp2 = 0 ;
19255 int res2 = 0 ;
19256 PyObject * obj0 = 0 ;
19257 PyObject * obj1 = 0 ;
19258 char * kwnames[] = {
19259 (char *) "self",(char *) "ft", NULL
19260 };
19261
19262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
19263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
19264 if (!SWIG_IsOK(res1)) {
19265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19266 }
19267 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
19269 if (!SWIG_IsOK(res2)) {
19270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
19271 }
19272 arg2 = reinterpret_cast< wxFileType * >(argp2);
19273 {
19274 PyThreadState* __tstate = wxPyBeginAllowThreads();
19275 result = (bool)(arg1)->Unassociate(arg2);
19276 wxPyEndAllowThreads(__tstate);
19277 if (PyErr_Occurred()) SWIG_fail;
19278 }
19279 {
19280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19281 }
19282 return resultobj;
19283 fail:
19284 return NULL;
19285 }
19286
19287
19288 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19289 PyObject *resultobj = 0;
19290 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
19291 void *argp1 = 0 ;
19292 int res1 = 0 ;
19293 PyObject *swig_obj[1] ;
19294
19295 if (!args) SWIG_fail;
19296 swig_obj[0] = args;
19297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
19298 if (!SWIG_IsOK(res1)) {
19299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
19300 }
19301 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
19302 {
19303 PyThreadState* __tstate = wxPyBeginAllowThreads();
19304 delete arg1;
19305
19306 wxPyEndAllowThreads(__tstate);
19307 if (PyErr_Occurred()) SWIG_fail;
19308 }
19309 resultobj = SWIG_Py_Void();
19310 return resultobj;
19311 fail:
19312 return NULL;
19313 }
19314
19315
19316 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19317 PyObject *obj;
19318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19319 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
19320 return SWIG_Py_Void();
19321 }
19322
19323 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19324 return SWIG_Python_InitShadowInstance(args);
19325 }
19326
19327 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
19328 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
19329 return 1;
19330 }
19331
19332
19333 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
19334 PyObject *pyobj = 0;
19335
19336 {
19337 #if wxUSE_UNICODE
19338 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19339 #else
19340 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
19341 #endif
19342 }
19343 return pyobj;
19344 }
19345
19346
19347 SWIGINTERN int ART_MENU_set(PyObject *) {
19348 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
19349 return 1;
19350 }
19351
19352
19353 SWIGINTERN PyObject *ART_MENU_get(void) {
19354 PyObject *pyobj = 0;
19355
19356 {
19357 #if wxUSE_UNICODE
19358 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19359 #else
19360 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
19361 #endif
19362 }
19363 return pyobj;
19364 }
19365
19366
19367 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
19368 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
19369 return 1;
19370 }
19371
19372
19373 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
19374 PyObject *pyobj = 0;
19375
19376 {
19377 #if wxUSE_UNICODE
19378 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19379 #else
19380 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
19381 #endif
19382 }
19383 return pyobj;
19384 }
19385
19386
19387 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
19388 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
19389 return 1;
19390 }
19391
19392
19393 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
19394 PyObject *pyobj = 0;
19395
19396 {
19397 #if wxUSE_UNICODE
19398 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19399 #else
19400 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
19401 #endif
19402 }
19403 return pyobj;
19404 }
19405
19406
19407 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
19408 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
19409 return 1;
19410 }
19411
19412
19413 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
19414 PyObject *pyobj = 0;
19415
19416 {
19417 #if wxUSE_UNICODE
19418 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19419 #else
19420 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
19421 #endif
19422 }
19423 return pyobj;
19424 }
19425
19426
19427 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
19428 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
19429 return 1;
19430 }
19431
19432
19433 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
19434 PyObject *pyobj = 0;
19435
19436 {
19437 #if wxUSE_UNICODE
19438 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19439 #else
19440 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
19441 #endif
19442 }
19443 return pyobj;
19444 }
19445
19446
19447 SWIGINTERN int ART_BUTTON_set(PyObject *) {
19448 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
19449 return 1;
19450 }
19451
19452
19453 SWIGINTERN PyObject *ART_BUTTON_get(void) {
19454 PyObject *pyobj = 0;
19455
19456 {
19457 #if wxUSE_UNICODE
19458 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19459 #else
19460 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
19461 #endif
19462 }
19463 return pyobj;
19464 }
19465
19466
19467 SWIGINTERN int ART_OTHER_set(PyObject *) {
19468 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
19469 return 1;
19470 }
19471
19472
19473 SWIGINTERN PyObject *ART_OTHER_get(void) {
19474 PyObject *pyobj = 0;
19475
19476 {
19477 #if wxUSE_UNICODE
19478 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19479 #else
19480 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
19481 #endif
19482 }
19483 return pyobj;
19484 }
19485
19486
19487 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
19488 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
19489 return 1;
19490 }
19491
19492
19493 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
19494 PyObject *pyobj = 0;
19495
19496 {
19497 #if wxUSE_UNICODE
19498 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19499 #else
19500 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
19501 #endif
19502 }
19503 return pyobj;
19504 }
19505
19506
19507 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
19508 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
19509 return 1;
19510 }
19511
19512
19513 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
19514 PyObject *pyobj = 0;
19515
19516 {
19517 #if wxUSE_UNICODE
19518 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19519 #else
19520 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
19521 #endif
19522 }
19523 return pyobj;
19524 }
19525
19526
19527 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
19528 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
19529 return 1;
19530 }
19531
19532
19533 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
19534 PyObject *pyobj = 0;
19535
19536 {
19537 #if wxUSE_UNICODE
19538 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19539 #else
19540 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
19541 #endif
19542 }
19543 return pyobj;
19544 }
19545
19546
19547 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
19548 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
19549 return 1;
19550 }
19551
19552
19553 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
19554 PyObject *pyobj = 0;
19555
19556 {
19557 #if wxUSE_UNICODE
19558 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19559 #else
19560 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
19561 #endif
19562 }
19563 return pyobj;
19564 }
19565
19566
19567 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
19568 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
19569 return 1;
19570 }
19571
19572
19573 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
19574 PyObject *pyobj = 0;
19575
19576 {
19577 #if wxUSE_UNICODE
19578 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19579 #else
19580 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
19581 #endif
19582 }
19583 return pyobj;
19584 }
19585
19586
19587 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
19588 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
19589 return 1;
19590 }
19591
19592
19593 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
19594 PyObject *pyobj = 0;
19595
19596 {
19597 #if wxUSE_UNICODE
19598 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19599 #else
19600 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
19601 #endif
19602 }
19603 return pyobj;
19604 }
19605
19606
19607 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
19608 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
19609 return 1;
19610 }
19611
19612
19613 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
19614 PyObject *pyobj = 0;
19615
19616 {
19617 #if wxUSE_UNICODE
19618 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19619 #else
19620 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
19621 #endif
19622 }
19623 return pyobj;
19624 }
19625
19626
19627 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
19628 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
19629 return 1;
19630 }
19631
19632
19633 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
19634 PyObject *pyobj = 0;
19635
19636 {
19637 #if wxUSE_UNICODE
19638 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19639 #else
19640 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
19641 #endif
19642 }
19643 return pyobj;
19644 }
19645
19646
19647 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
19648 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
19649 return 1;
19650 }
19651
19652
19653 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
19654 PyObject *pyobj = 0;
19655
19656 {
19657 #if wxUSE_UNICODE
19658 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19659 #else
19660 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
19661 #endif
19662 }
19663 return pyobj;
19664 }
19665
19666
19667 SWIGINTERN int ART_GO_UP_set(PyObject *) {
19668 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
19669 return 1;
19670 }
19671
19672
19673 SWIGINTERN PyObject *ART_GO_UP_get(void) {
19674 PyObject *pyobj = 0;
19675
19676 {
19677 #if wxUSE_UNICODE
19678 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19679 #else
19680 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
19681 #endif
19682 }
19683 return pyobj;
19684 }
19685
19686
19687 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
19688 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
19689 return 1;
19690 }
19691
19692
19693 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
19694 PyObject *pyobj = 0;
19695
19696 {
19697 #if wxUSE_UNICODE
19698 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19699 #else
19700 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
19701 #endif
19702 }
19703 return pyobj;
19704 }
19705
19706
19707 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
19708 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
19709 return 1;
19710 }
19711
19712
19713 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
19714 PyObject *pyobj = 0;
19715
19716 {
19717 #if wxUSE_UNICODE
19718 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19719 #else
19720 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
19721 #endif
19722 }
19723 return pyobj;
19724 }
19725
19726
19727 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
19728 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
19729 return 1;
19730 }
19731
19732
19733 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
19734 PyObject *pyobj = 0;
19735
19736 {
19737 #if wxUSE_UNICODE
19738 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19739 #else
19740 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
19741 #endif
19742 }
19743 return pyobj;
19744 }
19745
19746
19747 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
19748 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
19749 return 1;
19750 }
19751
19752
19753 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
19754 PyObject *pyobj = 0;
19755
19756 {
19757 #if wxUSE_UNICODE
19758 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19759 #else
19760 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
19761 #endif
19762 }
19763 return pyobj;
19764 }
19765
19766
19767 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
19768 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
19769 return 1;
19770 }
19771
19772
19773 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
19774 PyObject *pyobj = 0;
19775
19776 {
19777 #if wxUSE_UNICODE
19778 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19779 #else
19780 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
19781 #endif
19782 }
19783 return pyobj;
19784 }
19785
19786
19787 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
19788 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
19789 return 1;
19790 }
19791
19792
19793 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
19794 PyObject *pyobj = 0;
19795
19796 {
19797 #if wxUSE_UNICODE
19798 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19799 #else
19800 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
19801 #endif
19802 }
19803 return pyobj;
19804 }
19805
19806
19807 SWIGINTERN int ART_PRINT_set(PyObject *) {
19808 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
19809 return 1;
19810 }
19811
19812
19813 SWIGINTERN PyObject *ART_PRINT_get(void) {
19814 PyObject *pyobj = 0;
19815
19816 {
19817 #if wxUSE_UNICODE
19818 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19819 #else
19820 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
19821 #endif
19822 }
19823 return pyobj;
19824 }
19825
19826
19827 SWIGINTERN int ART_HELP_set(PyObject *) {
19828 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
19829 return 1;
19830 }
19831
19832
19833 SWIGINTERN PyObject *ART_HELP_get(void) {
19834 PyObject *pyobj = 0;
19835
19836 {
19837 #if wxUSE_UNICODE
19838 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19839 #else
19840 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
19841 #endif
19842 }
19843 return pyobj;
19844 }
19845
19846
19847 SWIGINTERN int ART_TIP_set(PyObject *) {
19848 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
19849 return 1;
19850 }
19851
19852
19853 SWIGINTERN PyObject *ART_TIP_get(void) {
19854 PyObject *pyobj = 0;
19855
19856 {
19857 #if wxUSE_UNICODE
19858 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19859 #else
19860 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
19861 #endif
19862 }
19863 return pyobj;
19864 }
19865
19866
19867 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
19868 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
19869 return 1;
19870 }
19871
19872
19873 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
19874 PyObject *pyobj = 0;
19875
19876 {
19877 #if wxUSE_UNICODE
19878 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19879 #else
19880 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
19881 #endif
19882 }
19883 return pyobj;
19884 }
19885
19886
19887 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
19888 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
19889 return 1;
19890 }
19891
19892
19893 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
19894 PyObject *pyobj = 0;
19895
19896 {
19897 #if wxUSE_UNICODE
19898 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19899 #else
19900 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
19901 #endif
19902 }
19903 return pyobj;
19904 }
19905
19906
19907 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
19908 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
19909 return 1;
19910 }
19911
19912
19913 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
19914 PyObject *pyobj = 0;
19915
19916 {
19917 #if wxUSE_UNICODE
19918 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19919 #else
19920 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
19921 #endif
19922 }
19923 return pyobj;
19924 }
19925
19926
19927 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
19928 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
19929 return 1;
19930 }
19931
19932
19933 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
19934 PyObject *pyobj = 0;
19935
19936 {
19937 #if wxUSE_UNICODE
19938 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19939 #else
19940 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
19941 #endif
19942 }
19943 return pyobj;
19944 }
19945
19946
19947 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
19948 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
19949 return 1;
19950 }
19951
19952
19953 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
19954 PyObject *pyobj = 0;
19955
19956 {
19957 #if wxUSE_UNICODE
19958 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19959 #else
19960 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
19961 #endif
19962 }
19963 return pyobj;
19964 }
19965
19966
19967 SWIGINTERN int ART_CDROM_set(PyObject *) {
19968 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
19969 return 1;
19970 }
19971
19972
19973 SWIGINTERN PyObject *ART_CDROM_get(void) {
19974 PyObject *pyobj = 0;
19975
19976 {
19977 #if wxUSE_UNICODE
19978 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19979 #else
19980 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
19981 #endif
19982 }
19983 return pyobj;
19984 }
19985
19986
19987 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
19988 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
19989 return 1;
19990 }
19991
19992
19993 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
19994 PyObject *pyobj = 0;
19995
19996 {
19997 #if wxUSE_UNICODE
19998 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
19999 #else
20000 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
20001 #endif
20002 }
20003 return pyobj;
20004 }
20005
20006
20007 SWIGINTERN int ART_FOLDER_set(PyObject *) {
20008 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
20009 return 1;
20010 }
20011
20012
20013 SWIGINTERN PyObject *ART_FOLDER_get(void) {
20014 PyObject *pyobj = 0;
20015
20016 {
20017 #if wxUSE_UNICODE
20018 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20019 #else
20020 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
20021 #endif
20022 }
20023 return pyobj;
20024 }
20025
20026
20027 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
20028 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
20029 return 1;
20030 }
20031
20032
20033 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
20034 PyObject *pyobj = 0;
20035
20036 {
20037 #if wxUSE_UNICODE
20038 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20039 #else
20040 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
20041 #endif
20042 }
20043 return pyobj;
20044 }
20045
20046
20047 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
20048 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
20049 return 1;
20050 }
20051
20052
20053 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
20054 PyObject *pyobj = 0;
20055
20056 {
20057 #if wxUSE_UNICODE
20058 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20059 #else
20060 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
20061 #endif
20062 }
20063 return pyobj;
20064 }
20065
20066
20067 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
20068 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
20069 return 1;
20070 }
20071
20072
20073 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
20074 PyObject *pyobj = 0;
20075
20076 {
20077 #if wxUSE_UNICODE
20078 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20079 #else
20080 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
20081 #endif
20082 }
20083 return pyobj;
20084 }
20085
20086
20087 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
20088 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
20089 return 1;
20090 }
20091
20092
20093 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
20094 PyObject *pyobj = 0;
20095
20096 {
20097 #if wxUSE_UNICODE
20098 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20099 #else
20100 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
20101 #endif
20102 }
20103 return pyobj;
20104 }
20105
20106
20107 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
20108 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
20109 return 1;
20110 }
20111
20112
20113 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
20114 PyObject *pyobj = 0;
20115
20116 {
20117 #if wxUSE_UNICODE
20118 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20119 #else
20120 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
20121 #endif
20122 }
20123 return pyobj;
20124 }
20125
20126
20127 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
20128 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
20129 return 1;
20130 }
20131
20132
20133 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
20134 PyObject *pyobj = 0;
20135
20136 {
20137 #if wxUSE_UNICODE
20138 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20139 #else
20140 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
20141 #endif
20142 }
20143 return pyobj;
20144 }
20145
20146
20147 SWIGINTERN int ART_ERROR_set(PyObject *) {
20148 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
20149 return 1;
20150 }
20151
20152
20153 SWIGINTERN PyObject *ART_ERROR_get(void) {
20154 PyObject *pyobj = 0;
20155
20156 {
20157 #if wxUSE_UNICODE
20158 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20159 #else
20160 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
20161 #endif
20162 }
20163 return pyobj;
20164 }
20165
20166
20167 SWIGINTERN int ART_QUESTION_set(PyObject *) {
20168 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
20169 return 1;
20170 }
20171
20172
20173 SWIGINTERN PyObject *ART_QUESTION_get(void) {
20174 PyObject *pyobj = 0;
20175
20176 {
20177 #if wxUSE_UNICODE
20178 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20179 #else
20180 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
20181 #endif
20182 }
20183 return pyobj;
20184 }
20185
20186
20187 SWIGINTERN int ART_WARNING_set(PyObject *) {
20188 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
20189 return 1;
20190 }
20191
20192
20193 SWIGINTERN PyObject *ART_WARNING_get(void) {
20194 PyObject *pyobj = 0;
20195
20196 {
20197 #if wxUSE_UNICODE
20198 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20199 #else
20200 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
20201 #endif
20202 }
20203 return pyobj;
20204 }
20205
20206
20207 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
20208 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
20209 return 1;
20210 }
20211
20212
20213 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
20214 PyObject *pyobj = 0;
20215
20216 {
20217 #if wxUSE_UNICODE
20218 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20219 #else
20220 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
20221 #endif
20222 }
20223 return pyobj;
20224 }
20225
20226
20227 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
20228 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
20229 return 1;
20230 }
20231
20232
20233 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
20234 PyObject *pyobj = 0;
20235
20236 {
20237 #if wxUSE_UNICODE
20238 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20239 #else
20240 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
20241 #endif
20242 }
20243 return pyobj;
20244 }
20245
20246
20247 SWIGINTERN int ART_COPY_set(PyObject *) {
20248 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
20249 return 1;
20250 }
20251
20252
20253 SWIGINTERN PyObject *ART_COPY_get(void) {
20254 PyObject *pyobj = 0;
20255
20256 {
20257 #if wxUSE_UNICODE
20258 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20259 #else
20260 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
20261 #endif
20262 }
20263 return pyobj;
20264 }
20265
20266
20267 SWIGINTERN int ART_CUT_set(PyObject *) {
20268 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
20269 return 1;
20270 }
20271
20272
20273 SWIGINTERN PyObject *ART_CUT_get(void) {
20274 PyObject *pyobj = 0;
20275
20276 {
20277 #if wxUSE_UNICODE
20278 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20279 #else
20280 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
20281 #endif
20282 }
20283 return pyobj;
20284 }
20285
20286
20287 SWIGINTERN int ART_PASTE_set(PyObject *) {
20288 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
20289 return 1;
20290 }
20291
20292
20293 SWIGINTERN PyObject *ART_PASTE_get(void) {
20294 PyObject *pyobj = 0;
20295
20296 {
20297 #if wxUSE_UNICODE
20298 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20299 #else
20300 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
20301 #endif
20302 }
20303 return pyobj;
20304 }
20305
20306
20307 SWIGINTERN int ART_DELETE_set(PyObject *) {
20308 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
20309 return 1;
20310 }
20311
20312
20313 SWIGINTERN PyObject *ART_DELETE_get(void) {
20314 PyObject *pyobj = 0;
20315
20316 {
20317 #if wxUSE_UNICODE
20318 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20319 #else
20320 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
20321 #endif
20322 }
20323 return pyobj;
20324 }
20325
20326
20327 SWIGINTERN int ART_NEW_set(PyObject *) {
20328 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
20329 return 1;
20330 }
20331
20332
20333 SWIGINTERN PyObject *ART_NEW_get(void) {
20334 PyObject *pyobj = 0;
20335
20336 {
20337 #if wxUSE_UNICODE
20338 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20339 #else
20340 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
20341 #endif
20342 }
20343 return pyobj;
20344 }
20345
20346
20347 SWIGINTERN int ART_UNDO_set(PyObject *) {
20348 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
20349 return 1;
20350 }
20351
20352
20353 SWIGINTERN PyObject *ART_UNDO_get(void) {
20354 PyObject *pyobj = 0;
20355
20356 {
20357 #if wxUSE_UNICODE
20358 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20359 #else
20360 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
20361 #endif
20362 }
20363 return pyobj;
20364 }
20365
20366
20367 SWIGINTERN int ART_REDO_set(PyObject *) {
20368 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
20369 return 1;
20370 }
20371
20372
20373 SWIGINTERN PyObject *ART_REDO_get(void) {
20374 PyObject *pyobj = 0;
20375
20376 {
20377 #if wxUSE_UNICODE
20378 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20379 #else
20380 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
20381 #endif
20382 }
20383 return pyobj;
20384 }
20385
20386
20387 SWIGINTERN int ART_QUIT_set(PyObject *) {
20388 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
20389 return 1;
20390 }
20391
20392
20393 SWIGINTERN PyObject *ART_QUIT_get(void) {
20394 PyObject *pyobj = 0;
20395
20396 {
20397 #if wxUSE_UNICODE
20398 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20399 #else
20400 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
20401 #endif
20402 }
20403 return pyobj;
20404 }
20405
20406
20407 SWIGINTERN int ART_FIND_set(PyObject *) {
20408 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
20409 return 1;
20410 }
20411
20412
20413 SWIGINTERN PyObject *ART_FIND_get(void) {
20414 PyObject *pyobj = 0;
20415
20416 {
20417 #if wxUSE_UNICODE
20418 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20419 #else
20420 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
20421 #endif
20422 }
20423 return pyobj;
20424 }
20425
20426
20427 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
20428 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
20429 return 1;
20430 }
20431
20432
20433 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
20434 PyObject *pyobj = 0;
20435
20436 {
20437 #if wxUSE_UNICODE
20438 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20439 #else
20440 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
20441 #endif
20442 }
20443 return pyobj;
20444 }
20445
20446
20447 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 PyObject *resultobj = 0;
20449 wxPyArtProvider *result = 0 ;
20450
20451 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
20452 {
20453 if (!wxPyCheckForApp()) SWIG_fail;
20454 PyThreadState* __tstate = wxPyBeginAllowThreads();
20455 result = (wxPyArtProvider *)new wxPyArtProvider();
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20467 PyObject *resultobj = 0;
20468 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20469 void *argp1 = 0 ;
20470 int res1 = 0 ;
20471 PyObject *swig_obj[1] ;
20472
20473 if (!args) SWIG_fail;
20474 swig_obj[0] = args;
20475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20476 if (!SWIG_IsOK(res1)) {
20477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20478 }
20479 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20480 {
20481 PyThreadState* __tstate = wxPyBeginAllowThreads();
20482 delete arg1;
20483
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 resultobj = SWIG_Py_Void();
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj = 0;
20496 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20497 PyObject *arg2 = (PyObject *) 0 ;
20498 PyObject *arg3 = (PyObject *) 0 ;
20499 void *argp1 = 0 ;
20500 int res1 = 0 ;
20501 PyObject * obj0 = 0 ;
20502 PyObject * obj1 = 0 ;
20503 PyObject * obj2 = 0 ;
20504 char * kwnames[] = {
20505 (char *) "self",(char *) "self",(char *) "_class", NULL
20506 };
20507
20508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20510 if (!SWIG_IsOK(res1)) {
20511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20512 }
20513 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20514 arg2 = obj1;
20515 arg3 = obj2;
20516 {
20517 PyThreadState* __tstate = wxPyBeginAllowThreads();
20518 (arg1)->_setCallbackInfo(arg2,arg3);
20519 wxPyEndAllowThreads(__tstate);
20520 if (PyErr_Occurred()) SWIG_fail;
20521 }
20522 resultobj = SWIG_Py_Void();
20523 return resultobj;
20524 fail:
20525 return NULL;
20526 }
20527
20528
20529 SWIGINTERN PyObject *_wrap_ArtProvider_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20530 PyObject *resultobj = 0;
20531 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20532 int res1 = 0 ;
20533 PyObject * obj0 = 0 ;
20534 char * kwnames[] = {
20535 (char *) "provider", NULL
20536 };
20537
20538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Push",kwnames,&obj0)) SWIG_fail;
20539 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20540 if (!SWIG_IsOK(res1)) {
20541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Push" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20542 }
20543 {
20544 PyThreadState* __tstate = wxPyBeginAllowThreads();
20545 wxPyArtProvider::Push(arg1);
20546 wxPyEndAllowThreads(__tstate);
20547 if (PyErr_Occurred()) SWIG_fail;
20548 }
20549 resultobj = SWIG_Py_Void();
20550 return resultobj;
20551 fail:
20552 return NULL;
20553 }
20554
20555
20556 SWIGINTERN PyObject *_wrap_ArtProvider_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20557 PyObject *resultobj = 0;
20558 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20559 int res1 = 0 ;
20560 PyObject * obj0 = 0 ;
20561 char * kwnames[] = {
20562 (char *) "provider", NULL
20563 };
20564
20565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Insert",kwnames,&obj0)) SWIG_fail;
20566 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
20567 if (!SWIG_IsOK(res1)) {
20568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Insert" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20569 }
20570 {
20571 PyThreadState* __tstate = wxPyBeginAllowThreads();
20572 wxPyArtProvider::Insert(arg1);
20573 wxPyEndAllowThreads(__tstate);
20574 if (PyErr_Occurred()) SWIG_fail;
20575 }
20576 resultobj = SWIG_Py_Void();
20577 return resultobj;
20578 fail:
20579 return NULL;
20580 }
20581
20582
20583 SWIGINTERN PyObject *_wrap_ArtProvider_Pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20584 PyObject *resultobj = 0;
20585 bool result;
20586
20587 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_Pop",0,0,0)) SWIG_fail;
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (bool)wxPyArtProvider::Pop();
20591 wxPyEndAllowThreads(__tstate);
20592 if (PyErr_Occurred()) SWIG_fail;
20593 }
20594 {
20595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20596 }
20597 return resultobj;
20598 fail:
20599 return NULL;
20600 }
20601
20602
20603 SWIGINTERN PyObject *_wrap_ArtProvider_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20604 PyObject *resultobj = 0;
20605 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20606 bool result;
20607 void *argp1 = 0 ;
20608 int res1 = 0 ;
20609 PyObject * obj0 = 0 ;
20610 char * kwnames[] = {
20611 (char *) "provider", NULL
20612 };
20613
20614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Delete",kwnames,&obj0)) SWIG_fail;
20615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20616 if (!SWIG_IsOK(res1)) {
20617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Delete" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20618 }
20619 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20620 {
20621 PyThreadState* __tstate = wxPyBeginAllowThreads();
20622 result = (bool)wxPyArtProvider::Delete(arg1);
20623 wxPyEndAllowThreads(__tstate);
20624 if (PyErr_Occurred()) SWIG_fail;
20625 }
20626 {
20627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20628 }
20629 return resultobj;
20630 fail:
20631 return NULL;
20632 }
20633
20634
20635 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20636 PyObject *resultobj = 0;
20637 wxString *arg1 = 0 ;
20638 wxString const &arg2_defvalue = wxPyART_OTHER ;
20639 wxString *arg2 = (wxString *) &arg2_defvalue ;
20640 wxSize const &arg3_defvalue = wxDefaultSize ;
20641 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20642 wxBitmap result;
20643 bool temp1 = false ;
20644 bool temp2 = false ;
20645 wxSize temp3 ;
20646 PyObject * obj0 = 0 ;
20647 PyObject * obj1 = 0 ;
20648 PyObject * obj2 = 0 ;
20649 char * kwnames[] = {
20650 (char *) "id",(char *) "client",(char *) "size", NULL
20651 };
20652
20653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20654 {
20655 arg1 = wxString_in_helper(obj0);
20656 if (arg1 == NULL) SWIG_fail;
20657 temp1 = true;
20658 }
20659 if (obj1) {
20660 {
20661 arg2 = wxString_in_helper(obj1);
20662 if (arg2 == NULL) SWIG_fail;
20663 temp2 = true;
20664 }
20665 }
20666 if (obj2) {
20667 {
20668 arg3 = &temp3;
20669 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20670 }
20671 }
20672 {
20673 if (!wxPyCheckForApp()) SWIG_fail;
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20680 {
20681 if (temp1)
20682 delete arg1;
20683 }
20684 {
20685 if (temp2)
20686 delete arg2;
20687 }
20688 return resultobj;
20689 fail:
20690 {
20691 if (temp1)
20692 delete arg1;
20693 }
20694 {
20695 if (temp2)
20696 delete arg2;
20697 }
20698 return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20703 PyObject *resultobj = 0;
20704 wxString *arg1 = 0 ;
20705 wxString const &arg2_defvalue = wxPyART_OTHER ;
20706 wxString *arg2 = (wxString *) &arg2_defvalue ;
20707 wxSize const &arg3_defvalue = wxDefaultSize ;
20708 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
20709 wxIcon result;
20710 bool temp1 = false ;
20711 bool temp2 = false ;
20712 wxSize temp3 ;
20713 PyObject * obj0 = 0 ;
20714 PyObject * obj1 = 0 ;
20715 PyObject * obj2 = 0 ;
20716 char * kwnames[] = {
20717 (char *) "id",(char *) "client",(char *) "size", NULL
20718 };
20719
20720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20721 {
20722 arg1 = wxString_in_helper(obj0);
20723 if (arg1 == NULL) SWIG_fail;
20724 temp1 = true;
20725 }
20726 if (obj1) {
20727 {
20728 arg2 = wxString_in_helper(obj1);
20729 if (arg2 == NULL) SWIG_fail;
20730 temp2 = true;
20731 }
20732 }
20733 if (obj2) {
20734 {
20735 arg3 = &temp3;
20736 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
20737 }
20738 }
20739 {
20740 if (!wxPyCheckForApp()) SWIG_fail;
20741 PyThreadState* __tstate = wxPyBeginAllowThreads();
20742 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
20743 wxPyEndAllowThreads(__tstate);
20744 if (PyErr_Occurred()) SWIG_fail;
20745 }
20746 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
20747 {
20748 if (temp1)
20749 delete arg1;
20750 }
20751 {
20752 if (temp2)
20753 delete arg2;
20754 }
20755 return resultobj;
20756 fail:
20757 {
20758 if (temp1)
20759 delete arg1;
20760 }
20761 {
20762 if (temp2)
20763 delete arg2;
20764 }
20765 return NULL;
20766 }
20767
20768
20769 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20770 PyObject *resultobj = 0;
20771 wxString *arg1 = 0 ;
20772 bool arg2 = (bool) false ;
20773 wxSize result;
20774 bool temp1 = false ;
20775 bool val2 ;
20776 int ecode2 = 0 ;
20777 PyObject * obj0 = 0 ;
20778 PyObject * obj1 = 0 ;
20779 char * kwnames[] = {
20780 (char *) "client",(char *) "platform_dependent", NULL
20781 };
20782
20783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
20784 {
20785 arg1 = wxString_in_helper(obj0);
20786 if (arg1 == NULL) SWIG_fail;
20787 temp1 = true;
20788 }
20789 if (obj1) {
20790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20791 if (!SWIG_IsOK(ecode2)) {
20792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
20793 }
20794 arg2 = static_cast< bool >(val2);
20795 }
20796 {
20797 PyThreadState* __tstate = wxPyBeginAllowThreads();
20798 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
20803 {
20804 if (temp1)
20805 delete arg1;
20806 }
20807 return resultobj;
20808 fail:
20809 {
20810 if (temp1)
20811 delete arg1;
20812 }
20813 return NULL;
20814 }
20815
20816
20817 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20818 PyObject *resultobj = 0;
20819 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
20820 void *argp1 = 0 ;
20821 int res1 = 0 ;
20822 PyObject *swig_obj[1] ;
20823
20824 if (!args) SWIG_fail;
20825 swig_obj[0] = args;
20826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
20827 if (!SWIG_IsOK(res1)) {
20828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
20829 }
20830 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
20831 {
20832 PyThreadState* __tstate = wxPyBeginAllowThreads();
20833 wxPyArtProvider_Destroy(arg1);
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 resultobj = SWIG_Py_Void();
20838 return resultobj;
20839 fail:
20840 return NULL;
20841 }
20842
20843
20844 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20845 PyObject *obj;
20846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20847 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
20848 return SWIG_Py_Void();
20849 }
20850
20851 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20852 return SWIG_Python_InitShadowInstance(args);
20853 }
20854
20855 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20856 PyObject *resultobj = 0;
20857 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20858 void *argp1 = 0 ;
20859 int res1 = 0 ;
20860 PyObject *swig_obj[1] ;
20861
20862 if (!args) SWIG_fail;
20863 swig_obj[0] = args;
20864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20867 }
20868 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 delete arg1;
20872
20873 wxPyEndAllowThreads(__tstate);
20874 if (PyErr_Occurred()) SWIG_fail;
20875 }
20876 resultobj = SWIG_Py_Void();
20877 return resultobj;
20878 fail:
20879 return NULL;
20880 }
20881
20882
20883 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20884 PyObject *resultobj = 0;
20885 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20886 wxConfigBase *result = 0 ;
20887 int res1 = 0 ;
20888 PyObject * obj0 = 0 ;
20889 char * kwnames[] = {
20890 (char *) "config", NULL
20891 };
20892
20893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
20894 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
20895 if (!SWIG_IsOK(res1)) {
20896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20897 }
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 result = (wxConfigBase *)wxConfigBase::Set(arg1);
20901 wxPyEndAllowThreads(__tstate);
20902 if (PyErr_Occurred()) SWIG_fail;
20903 }
20904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20905 return resultobj;
20906 fail:
20907 return NULL;
20908 }
20909
20910
20911 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20912 PyObject *resultobj = 0;
20913 bool arg1 = (bool) true ;
20914 wxConfigBase *result = 0 ;
20915 bool val1 ;
20916 int ecode1 = 0 ;
20917 PyObject * obj0 = 0 ;
20918 char * kwnames[] = {
20919 (char *) "createOnDemand", NULL
20920 };
20921
20922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
20923 if (obj0) {
20924 ecode1 = SWIG_AsVal_bool(obj0, &val1);
20925 if (!SWIG_IsOK(ecode1)) {
20926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
20927 }
20928 arg1 = static_cast< bool >(val1);
20929 }
20930 {
20931 PyThreadState* __tstate = wxPyBeginAllowThreads();
20932 result = (wxConfigBase *)wxConfigBase::Get(arg1);
20933 wxPyEndAllowThreads(__tstate);
20934 if (PyErr_Occurred()) SWIG_fail;
20935 }
20936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20937 return resultobj;
20938 fail:
20939 return NULL;
20940 }
20941
20942
20943 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20944 PyObject *resultobj = 0;
20945 wxConfigBase *result = 0 ;
20946
20947 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (wxConfigBase *)wxConfigBase::Create();
20951 wxPyEndAllowThreads(__tstate);
20952 if (PyErr_Occurred()) SWIG_fail;
20953 }
20954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
20955 return resultobj;
20956 fail:
20957 return NULL;
20958 }
20959
20960
20961 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20962 PyObject *resultobj = 0;
20963
20964 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
20965 {
20966 PyThreadState* __tstate = wxPyBeginAllowThreads();
20967 wxConfigBase::DontCreateOnDemand();
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 resultobj = SWIG_Py_Void();
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20979 PyObject *resultobj = 0;
20980 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20981 wxString *arg2 = 0 ;
20982 void *argp1 = 0 ;
20983 int res1 = 0 ;
20984 bool temp2 = false ;
20985 PyObject * obj0 = 0 ;
20986 PyObject * obj1 = 0 ;
20987 char * kwnames[] = {
20988 (char *) "self",(char *) "path", NULL
20989 };
20990
20991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
20992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20993 if (!SWIG_IsOK(res1)) {
20994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20995 }
20996 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20997 {
20998 arg2 = wxString_in_helper(obj1);
20999 if (arg2 == NULL) SWIG_fail;
21000 temp2 = true;
21001 }
21002 {
21003 PyThreadState* __tstate = wxPyBeginAllowThreads();
21004 (arg1)->SetPath((wxString const &)*arg2);
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 resultobj = SWIG_Py_Void();
21009 {
21010 if (temp2)
21011 delete arg2;
21012 }
21013 return resultobj;
21014 fail:
21015 {
21016 if (temp2)
21017 delete arg2;
21018 }
21019 return NULL;
21020 }
21021
21022
21023 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21024 PyObject *resultobj = 0;
21025 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21026 wxString *result = 0 ;
21027 void *argp1 = 0 ;
21028 int res1 = 0 ;
21029 PyObject *swig_obj[1] ;
21030
21031 if (!args) SWIG_fail;
21032 swig_obj[0] = args;
21033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21034 if (!SWIG_IsOK(res1)) {
21035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21036 }
21037 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 {
21041 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
21042 result = (wxString *) &_result_ref;
21043 }
21044 wxPyEndAllowThreads(__tstate);
21045 if (PyErr_Occurred()) SWIG_fail;
21046 }
21047 {
21048 #if wxUSE_UNICODE
21049 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21050 #else
21051 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21052 #endif
21053 }
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21061 PyObject *resultobj = 0;
21062 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21063 PyObject *result = 0 ;
21064 void *argp1 = 0 ;
21065 int res1 = 0 ;
21066 PyObject *swig_obj[1] ;
21067
21068 if (!args) SWIG_fail;
21069 swig_obj[0] = args;
21070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21071 if (!SWIG_IsOK(res1)) {
21072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21073 }
21074 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21075 {
21076 PyThreadState* __tstate = wxPyBeginAllowThreads();
21077 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
21078 wxPyEndAllowThreads(__tstate);
21079 if (PyErr_Occurred()) SWIG_fail;
21080 }
21081 resultobj = result;
21082 return resultobj;
21083 fail:
21084 return NULL;
21085 }
21086
21087
21088 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21089 PyObject *resultobj = 0;
21090 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21091 long arg2 ;
21092 PyObject *result = 0 ;
21093 void *argp1 = 0 ;
21094 int res1 = 0 ;
21095 long val2 ;
21096 int ecode2 = 0 ;
21097 PyObject * obj0 = 0 ;
21098 PyObject * obj1 = 0 ;
21099 char * kwnames[] = {
21100 (char *) "self",(char *) "index", NULL
21101 };
21102
21103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21105 if (!SWIG_IsOK(res1)) {
21106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21107 }
21108 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21109 ecode2 = SWIG_AsVal_long(obj1, &val2);
21110 if (!SWIG_IsOK(ecode2)) {
21111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
21112 }
21113 arg2 = static_cast< long >(val2);
21114 {
21115 PyThreadState* __tstate = wxPyBeginAllowThreads();
21116 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 resultobj = result;
21121 return resultobj;
21122 fail:
21123 return NULL;
21124 }
21125
21126
21127 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21128 PyObject *resultobj = 0;
21129 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21130 PyObject *result = 0 ;
21131 void *argp1 = 0 ;
21132 int res1 = 0 ;
21133 PyObject *swig_obj[1] ;
21134
21135 if (!args) SWIG_fail;
21136 swig_obj[0] = args;
21137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21138 if (!SWIG_IsOK(res1)) {
21139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21140 }
21141 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21142 {
21143 PyThreadState* __tstate = wxPyBeginAllowThreads();
21144 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
21145 wxPyEndAllowThreads(__tstate);
21146 if (PyErr_Occurred()) SWIG_fail;
21147 }
21148 resultobj = result;
21149 return resultobj;
21150 fail:
21151 return NULL;
21152 }
21153
21154
21155 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21156 PyObject *resultobj = 0;
21157 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21158 long arg2 ;
21159 PyObject *result = 0 ;
21160 void *argp1 = 0 ;
21161 int res1 = 0 ;
21162 long val2 ;
21163 int ecode2 = 0 ;
21164 PyObject * obj0 = 0 ;
21165 PyObject * obj1 = 0 ;
21166 char * kwnames[] = {
21167 (char *) "self",(char *) "index", NULL
21168 };
21169
21170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21172 if (!SWIG_IsOK(res1)) {
21173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21174 }
21175 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21176 ecode2 = SWIG_AsVal_long(obj1, &val2);
21177 if (!SWIG_IsOK(ecode2)) {
21178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
21179 }
21180 arg2 = static_cast< long >(val2);
21181 {
21182 PyThreadState* __tstate = wxPyBeginAllowThreads();
21183 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
21184 wxPyEndAllowThreads(__tstate);
21185 if (PyErr_Occurred()) SWIG_fail;
21186 }
21187 resultobj = result;
21188 return resultobj;
21189 fail:
21190 return NULL;
21191 }
21192
21193
21194 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21195 PyObject *resultobj = 0;
21196 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21197 bool arg2 = (bool) false ;
21198 size_t result;
21199 void *argp1 = 0 ;
21200 int res1 = 0 ;
21201 bool val2 ;
21202 int ecode2 = 0 ;
21203 PyObject * obj0 = 0 ;
21204 PyObject * obj1 = 0 ;
21205 char * kwnames[] = {
21206 (char *) "self",(char *) "recursive", NULL
21207 };
21208
21209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
21210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21211 if (!SWIG_IsOK(res1)) {
21212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21213 }
21214 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21215 if (obj1) {
21216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21217 if (!SWIG_IsOK(ecode2)) {
21218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
21219 }
21220 arg2 = static_cast< bool >(val2);
21221 }
21222 {
21223 PyThreadState* __tstate = wxPyBeginAllowThreads();
21224 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
21225 wxPyEndAllowThreads(__tstate);
21226 if (PyErr_Occurred()) SWIG_fail;
21227 }
21228 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21229 return resultobj;
21230 fail:
21231 return NULL;
21232 }
21233
21234
21235 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21236 PyObject *resultobj = 0;
21237 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21238 bool arg2 = (bool) false ;
21239 size_t result;
21240 void *argp1 = 0 ;
21241 int res1 = 0 ;
21242 bool val2 ;
21243 int ecode2 = 0 ;
21244 PyObject * obj0 = 0 ;
21245 PyObject * obj1 = 0 ;
21246 char * kwnames[] = {
21247 (char *) "self",(char *) "recursive", NULL
21248 };
21249
21250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
21251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21252 if (!SWIG_IsOK(res1)) {
21253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21254 }
21255 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21256 if (obj1) {
21257 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21258 if (!SWIG_IsOK(ecode2)) {
21259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
21260 }
21261 arg2 = static_cast< bool >(val2);
21262 }
21263 {
21264 PyThreadState* __tstate = wxPyBeginAllowThreads();
21265 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
21266 wxPyEndAllowThreads(__tstate);
21267 if (PyErr_Occurred()) SWIG_fail;
21268 }
21269 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21277 PyObject *resultobj = 0;
21278 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21279 wxString *arg2 = 0 ;
21280 bool result;
21281 void *argp1 = 0 ;
21282 int res1 = 0 ;
21283 bool temp2 = false ;
21284 PyObject * obj0 = 0 ;
21285 PyObject * obj1 = 0 ;
21286 char * kwnames[] = {
21287 (char *) "self",(char *) "name", NULL
21288 };
21289
21290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21292 if (!SWIG_IsOK(res1)) {
21293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21294 }
21295 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21296 {
21297 arg2 = wxString_in_helper(obj1);
21298 if (arg2 == NULL) SWIG_fail;
21299 temp2 = true;
21300 }
21301 {
21302 PyThreadState* __tstate = wxPyBeginAllowThreads();
21303 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 {
21308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21309 }
21310 {
21311 if (temp2)
21312 delete arg2;
21313 }
21314 return resultobj;
21315 fail:
21316 {
21317 if (temp2)
21318 delete arg2;
21319 }
21320 return NULL;
21321 }
21322
21323
21324 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21325 PyObject *resultobj = 0;
21326 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21327 wxString *arg2 = 0 ;
21328 bool result;
21329 void *argp1 = 0 ;
21330 int res1 = 0 ;
21331 bool temp2 = false ;
21332 PyObject * obj0 = 0 ;
21333 PyObject * obj1 = 0 ;
21334 char * kwnames[] = {
21335 (char *) "self",(char *) "name", NULL
21336 };
21337
21338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
21339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21340 if (!SWIG_IsOK(res1)) {
21341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21342 }
21343 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21344 {
21345 arg2 = wxString_in_helper(obj1);
21346 if (arg2 == NULL) SWIG_fail;
21347 temp2 = true;
21348 }
21349 {
21350 PyThreadState* __tstate = wxPyBeginAllowThreads();
21351 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
21352 wxPyEndAllowThreads(__tstate);
21353 if (PyErr_Occurred()) SWIG_fail;
21354 }
21355 {
21356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21357 }
21358 {
21359 if (temp2)
21360 delete arg2;
21361 }
21362 return resultobj;
21363 fail:
21364 {
21365 if (temp2)
21366 delete arg2;
21367 }
21368 return NULL;
21369 }
21370
21371
21372 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21373 PyObject *resultobj = 0;
21374 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21375 wxString *arg2 = 0 ;
21376 bool result;
21377 void *argp1 = 0 ;
21378 int res1 = 0 ;
21379 bool temp2 = false ;
21380 PyObject * obj0 = 0 ;
21381 PyObject * obj1 = 0 ;
21382 char * kwnames[] = {
21383 (char *) "self",(char *) "name", NULL
21384 };
21385
21386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
21387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21388 if (!SWIG_IsOK(res1)) {
21389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21390 }
21391 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21392 {
21393 arg2 = wxString_in_helper(obj1);
21394 if (arg2 == NULL) SWIG_fail;
21395 temp2 = true;
21396 }
21397 {
21398 PyThreadState* __tstate = wxPyBeginAllowThreads();
21399 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 {
21404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21405 }
21406 {
21407 if (temp2)
21408 delete arg2;
21409 }
21410 return resultobj;
21411 fail:
21412 {
21413 if (temp2)
21414 delete arg2;
21415 }
21416 return NULL;
21417 }
21418
21419
21420 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21421 PyObject *resultobj = 0;
21422 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21423 wxString *arg2 = 0 ;
21424 wxConfigBase::EntryType result;
21425 void *argp1 = 0 ;
21426 int res1 = 0 ;
21427 bool temp2 = false ;
21428 PyObject * obj0 = 0 ;
21429 PyObject * obj1 = 0 ;
21430 char * kwnames[] = {
21431 (char *) "self",(char *) "name", NULL
21432 };
21433
21434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
21435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21436 if (!SWIG_IsOK(res1)) {
21437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21438 }
21439 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21440 {
21441 arg2 = wxString_in_helper(obj1);
21442 if (arg2 == NULL) SWIG_fail;
21443 temp2 = true;
21444 }
21445 {
21446 PyThreadState* __tstate = wxPyBeginAllowThreads();
21447 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
21448 wxPyEndAllowThreads(__tstate);
21449 if (PyErr_Occurred()) SWIG_fail;
21450 }
21451 resultobj = SWIG_From_int(static_cast< int >(result));
21452 {
21453 if (temp2)
21454 delete arg2;
21455 }
21456 return resultobj;
21457 fail:
21458 {
21459 if (temp2)
21460 delete arg2;
21461 }
21462 return NULL;
21463 }
21464
21465
21466 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21467 PyObject *resultobj = 0;
21468 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21469 wxString *arg2 = 0 ;
21470 wxString const &arg3_defvalue = wxPyEmptyString ;
21471 wxString *arg3 = (wxString *) &arg3_defvalue ;
21472 wxString result;
21473 void *argp1 = 0 ;
21474 int res1 = 0 ;
21475 bool temp2 = false ;
21476 bool temp3 = false ;
21477 PyObject * obj0 = 0 ;
21478 PyObject * obj1 = 0 ;
21479 PyObject * obj2 = 0 ;
21480 char * kwnames[] = {
21481 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21482 };
21483
21484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21486 if (!SWIG_IsOK(res1)) {
21487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21488 }
21489 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21490 {
21491 arg2 = wxString_in_helper(obj1);
21492 if (arg2 == NULL) SWIG_fail;
21493 temp2 = true;
21494 }
21495 if (obj2) {
21496 {
21497 arg3 = wxString_in_helper(obj2);
21498 if (arg3 == NULL) SWIG_fail;
21499 temp3 = true;
21500 }
21501 }
21502 {
21503 PyThreadState* __tstate = wxPyBeginAllowThreads();
21504 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
21505 wxPyEndAllowThreads(__tstate);
21506 if (PyErr_Occurred()) SWIG_fail;
21507 }
21508 {
21509 #if wxUSE_UNICODE
21510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21511 #else
21512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21513 #endif
21514 }
21515 {
21516 if (temp2)
21517 delete arg2;
21518 }
21519 {
21520 if (temp3)
21521 delete arg3;
21522 }
21523 return resultobj;
21524 fail:
21525 {
21526 if (temp2)
21527 delete arg2;
21528 }
21529 {
21530 if (temp3)
21531 delete arg3;
21532 }
21533 return NULL;
21534 }
21535
21536
21537 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21538 PyObject *resultobj = 0;
21539 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21540 wxString *arg2 = 0 ;
21541 long arg3 = (long) 0 ;
21542 long result;
21543 void *argp1 = 0 ;
21544 int res1 = 0 ;
21545 bool temp2 = false ;
21546 long val3 ;
21547 int ecode3 = 0 ;
21548 PyObject * obj0 = 0 ;
21549 PyObject * obj1 = 0 ;
21550 PyObject * obj2 = 0 ;
21551 char * kwnames[] = {
21552 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21553 };
21554
21555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21557 if (!SWIG_IsOK(res1)) {
21558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21559 }
21560 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21561 {
21562 arg2 = wxString_in_helper(obj1);
21563 if (arg2 == NULL) SWIG_fail;
21564 temp2 = true;
21565 }
21566 if (obj2) {
21567 ecode3 = SWIG_AsVal_long(obj2, &val3);
21568 if (!SWIG_IsOK(ecode3)) {
21569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
21570 }
21571 arg3 = static_cast< long >(val3);
21572 }
21573 {
21574 PyThreadState* __tstate = wxPyBeginAllowThreads();
21575 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
21576 wxPyEndAllowThreads(__tstate);
21577 if (PyErr_Occurred()) SWIG_fail;
21578 }
21579 resultobj = SWIG_From_long(static_cast< long >(result));
21580 {
21581 if (temp2)
21582 delete arg2;
21583 }
21584 return resultobj;
21585 fail:
21586 {
21587 if (temp2)
21588 delete arg2;
21589 }
21590 return NULL;
21591 }
21592
21593
21594 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21595 PyObject *resultobj = 0;
21596 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21597 wxString *arg2 = 0 ;
21598 double arg3 = (double) 0.0 ;
21599 double result;
21600 void *argp1 = 0 ;
21601 int res1 = 0 ;
21602 bool temp2 = false ;
21603 double val3 ;
21604 int ecode3 = 0 ;
21605 PyObject * obj0 = 0 ;
21606 PyObject * obj1 = 0 ;
21607 PyObject * obj2 = 0 ;
21608 char * kwnames[] = {
21609 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21610 };
21611
21612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21614 if (!SWIG_IsOK(res1)) {
21615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21616 }
21617 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21618 {
21619 arg2 = wxString_in_helper(obj1);
21620 if (arg2 == NULL) SWIG_fail;
21621 temp2 = true;
21622 }
21623 if (obj2) {
21624 ecode3 = SWIG_AsVal_double(obj2, &val3);
21625 if (!SWIG_IsOK(ecode3)) {
21626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
21627 }
21628 arg3 = static_cast< double >(val3);
21629 }
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
21633 wxPyEndAllowThreads(__tstate);
21634 if (PyErr_Occurred()) SWIG_fail;
21635 }
21636 resultobj = SWIG_From_double(static_cast< double >(result));
21637 {
21638 if (temp2)
21639 delete arg2;
21640 }
21641 return resultobj;
21642 fail:
21643 {
21644 if (temp2)
21645 delete arg2;
21646 }
21647 return NULL;
21648 }
21649
21650
21651 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21652 PyObject *resultobj = 0;
21653 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21654 wxString *arg2 = 0 ;
21655 bool arg3 = (bool) false ;
21656 bool result;
21657 void *argp1 = 0 ;
21658 int res1 = 0 ;
21659 bool temp2 = false ;
21660 bool val3 ;
21661 int ecode3 = 0 ;
21662 PyObject * obj0 = 0 ;
21663 PyObject * obj1 = 0 ;
21664 PyObject * obj2 = 0 ;
21665 char * kwnames[] = {
21666 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
21667 };
21668
21669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21671 if (!SWIG_IsOK(res1)) {
21672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21673 }
21674 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21675 {
21676 arg2 = wxString_in_helper(obj1);
21677 if (arg2 == NULL) SWIG_fail;
21678 temp2 = true;
21679 }
21680 if (obj2) {
21681 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21682 if (!SWIG_IsOK(ecode3)) {
21683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
21684 }
21685 arg3 = static_cast< bool >(val3);
21686 }
21687 {
21688 PyThreadState* __tstate = wxPyBeginAllowThreads();
21689 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 {
21694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21695 }
21696 {
21697 if (temp2)
21698 delete arg2;
21699 }
21700 return resultobj;
21701 fail:
21702 {
21703 if (temp2)
21704 delete arg2;
21705 }
21706 return NULL;
21707 }
21708
21709
21710 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21711 PyObject *resultobj = 0;
21712 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21713 wxString *arg2 = 0 ;
21714 wxString *arg3 = 0 ;
21715 bool result;
21716 void *argp1 = 0 ;
21717 int res1 = 0 ;
21718 bool temp2 = false ;
21719 bool temp3 = false ;
21720 PyObject * obj0 = 0 ;
21721 PyObject * obj1 = 0 ;
21722 PyObject * obj2 = 0 ;
21723 char * kwnames[] = {
21724 (char *) "self",(char *) "key",(char *) "value", NULL
21725 };
21726
21727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21729 if (!SWIG_IsOK(res1)) {
21730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21731 }
21732 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21733 {
21734 arg2 = wxString_in_helper(obj1);
21735 if (arg2 == NULL) SWIG_fail;
21736 temp2 = true;
21737 }
21738 {
21739 arg3 = wxString_in_helper(obj2);
21740 if (arg3 == NULL) SWIG_fail;
21741 temp3 = true;
21742 }
21743 {
21744 PyThreadState* __tstate = wxPyBeginAllowThreads();
21745 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
21746 wxPyEndAllowThreads(__tstate);
21747 if (PyErr_Occurred()) SWIG_fail;
21748 }
21749 {
21750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21751 }
21752 {
21753 if (temp2)
21754 delete arg2;
21755 }
21756 {
21757 if (temp3)
21758 delete arg3;
21759 }
21760 return resultobj;
21761 fail:
21762 {
21763 if (temp2)
21764 delete arg2;
21765 }
21766 {
21767 if (temp3)
21768 delete arg3;
21769 }
21770 return NULL;
21771 }
21772
21773
21774 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21775 PyObject *resultobj = 0;
21776 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21777 wxString *arg2 = 0 ;
21778 long arg3 ;
21779 bool result;
21780 void *argp1 = 0 ;
21781 int res1 = 0 ;
21782 bool temp2 = false ;
21783 long val3 ;
21784 int ecode3 = 0 ;
21785 PyObject * obj0 = 0 ;
21786 PyObject * obj1 = 0 ;
21787 PyObject * obj2 = 0 ;
21788 char * kwnames[] = {
21789 (char *) "self",(char *) "key",(char *) "value", NULL
21790 };
21791
21792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21794 if (!SWIG_IsOK(res1)) {
21795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21796 }
21797 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21798 {
21799 arg2 = wxString_in_helper(obj1);
21800 if (arg2 == NULL) SWIG_fail;
21801 temp2 = true;
21802 }
21803 ecode3 = SWIG_AsVal_long(obj2, &val3);
21804 if (!SWIG_IsOK(ecode3)) {
21805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
21806 }
21807 arg3 = static_cast< long >(val3);
21808 {
21809 PyThreadState* __tstate = wxPyBeginAllowThreads();
21810 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21811 wxPyEndAllowThreads(__tstate);
21812 if (PyErr_Occurred()) SWIG_fail;
21813 }
21814 {
21815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21816 }
21817 {
21818 if (temp2)
21819 delete arg2;
21820 }
21821 return resultobj;
21822 fail:
21823 {
21824 if (temp2)
21825 delete arg2;
21826 }
21827 return NULL;
21828 }
21829
21830
21831 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21832 PyObject *resultobj = 0;
21833 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21834 wxString *arg2 = 0 ;
21835 double arg3 ;
21836 bool result;
21837 void *argp1 = 0 ;
21838 int res1 = 0 ;
21839 bool temp2 = false ;
21840 double val3 ;
21841 int ecode3 = 0 ;
21842 PyObject * obj0 = 0 ;
21843 PyObject * obj1 = 0 ;
21844 PyObject * obj2 = 0 ;
21845 char * kwnames[] = {
21846 (char *) "self",(char *) "key",(char *) "value", NULL
21847 };
21848
21849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21851 if (!SWIG_IsOK(res1)) {
21852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21853 }
21854 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21855 {
21856 arg2 = wxString_in_helper(obj1);
21857 if (arg2 == NULL) SWIG_fail;
21858 temp2 = true;
21859 }
21860 ecode3 = SWIG_AsVal_double(obj2, &val3);
21861 if (!SWIG_IsOK(ecode3)) {
21862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
21863 }
21864 arg3 = static_cast< double >(val3);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 {
21872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21873 }
21874 {
21875 if (temp2)
21876 delete arg2;
21877 }
21878 return resultobj;
21879 fail:
21880 {
21881 if (temp2)
21882 delete arg2;
21883 }
21884 return NULL;
21885 }
21886
21887
21888 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21889 PyObject *resultobj = 0;
21890 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21891 wxString *arg2 = 0 ;
21892 bool arg3 ;
21893 bool result;
21894 void *argp1 = 0 ;
21895 int res1 = 0 ;
21896 bool temp2 = false ;
21897 bool val3 ;
21898 int ecode3 = 0 ;
21899 PyObject * obj0 = 0 ;
21900 PyObject * obj1 = 0 ;
21901 PyObject * obj2 = 0 ;
21902 char * kwnames[] = {
21903 (char *) "self",(char *) "key",(char *) "value", NULL
21904 };
21905
21906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21908 if (!SWIG_IsOK(res1)) {
21909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21910 }
21911 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21912 {
21913 arg2 = wxString_in_helper(obj1);
21914 if (arg2 == NULL) SWIG_fail;
21915 temp2 = true;
21916 }
21917 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21918 if (!SWIG_IsOK(ecode3)) {
21919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
21920 }
21921 arg3 = static_cast< bool >(val3);
21922 {
21923 PyThreadState* __tstate = wxPyBeginAllowThreads();
21924 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
21925 wxPyEndAllowThreads(__tstate);
21926 if (PyErr_Occurred()) SWIG_fail;
21927 }
21928 {
21929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21930 }
21931 {
21932 if (temp2)
21933 delete arg2;
21934 }
21935 return resultobj;
21936 fail:
21937 {
21938 if (temp2)
21939 delete arg2;
21940 }
21941 return NULL;
21942 }
21943
21944
21945 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21946 PyObject *resultobj = 0;
21947 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21948 bool arg2 = (bool) false ;
21949 bool result;
21950 void *argp1 = 0 ;
21951 int res1 = 0 ;
21952 bool val2 ;
21953 int ecode2 = 0 ;
21954 PyObject * obj0 = 0 ;
21955 PyObject * obj1 = 0 ;
21956 char * kwnames[] = {
21957 (char *) "self",(char *) "currentOnly", NULL
21958 };
21959
21960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
21961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21962 if (!SWIG_IsOK(res1)) {
21963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21964 }
21965 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21966 if (obj1) {
21967 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21968 if (!SWIG_IsOK(ecode2)) {
21969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
21970 }
21971 arg2 = static_cast< bool >(val2);
21972 }
21973 {
21974 PyThreadState* __tstate = wxPyBeginAllowThreads();
21975 result = (bool)(arg1)->Flush(arg2);
21976 wxPyEndAllowThreads(__tstate);
21977 if (PyErr_Occurred()) SWIG_fail;
21978 }
21979 {
21980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21981 }
21982 return resultobj;
21983 fail:
21984 return NULL;
21985 }
21986
21987
21988 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21989 PyObject *resultobj = 0;
21990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21991 wxString *arg2 = 0 ;
21992 wxString *arg3 = 0 ;
21993 bool result;
21994 void *argp1 = 0 ;
21995 int res1 = 0 ;
21996 bool temp2 = false ;
21997 bool temp3 = false ;
21998 PyObject * obj0 = 0 ;
21999 PyObject * obj1 = 0 ;
22000 PyObject * obj2 = 0 ;
22001 char * kwnames[] = {
22002 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22003 };
22004
22005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22007 if (!SWIG_IsOK(res1)) {
22008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22009 }
22010 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22011 {
22012 arg2 = wxString_in_helper(obj1);
22013 if (arg2 == NULL) SWIG_fail;
22014 temp2 = true;
22015 }
22016 {
22017 arg3 = wxString_in_helper(obj2);
22018 if (arg3 == NULL) SWIG_fail;
22019 temp3 = true;
22020 }
22021 {
22022 PyThreadState* __tstate = wxPyBeginAllowThreads();
22023 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
22024 wxPyEndAllowThreads(__tstate);
22025 if (PyErr_Occurred()) SWIG_fail;
22026 }
22027 {
22028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22029 }
22030 {
22031 if (temp2)
22032 delete arg2;
22033 }
22034 {
22035 if (temp3)
22036 delete arg3;
22037 }
22038 return resultobj;
22039 fail:
22040 {
22041 if (temp2)
22042 delete arg2;
22043 }
22044 {
22045 if (temp3)
22046 delete arg3;
22047 }
22048 return NULL;
22049 }
22050
22051
22052 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22053 PyObject *resultobj = 0;
22054 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22055 wxString *arg2 = 0 ;
22056 wxString *arg3 = 0 ;
22057 bool result;
22058 void *argp1 = 0 ;
22059 int res1 = 0 ;
22060 bool temp2 = false ;
22061 bool temp3 = false ;
22062 PyObject * obj0 = 0 ;
22063 PyObject * obj1 = 0 ;
22064 PyObject * obj2 = 0 ;
22065 char * kwnames[] = {
22066 (char *) "self",(char *) "oldName",(char *) "newName", NULL
22067 };
22068
22069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22071 if (!SWIG_IsOK(res1)) {
22072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22073 }
22074 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22075 {
22076 arg2 = wxString_in_helper(obj1);
22077 if (arg2 == NULL) SWIG_fail;
22078 temp2 = true;
22079 }
22080 {
22081 arg3 = wxString_in_helper(obj2);
22082 if (arg3 == NULL) SWIG_fail;
22083 temp3 = true;
22084 }
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 {
22092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22093 }
22094 {
22095 if (temp2)
22096 delete arg2;
22097 }
22098 {
22099 if (temp3)
22100 delete arg3;
22101 }
22102 return resultobj;
22103 fail:
22104 {
22105 if (temp2)
22106 delete arg2;
22107 }
22108 {
22109 if (temp3)
22110 delete arg3;
22111 }
22112 return NULL;
22113 }
22114
22115
22116 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22117 PyObject *resultobj = 0;
22118 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22119 wxString *arg2 = 0 ;
22120 bool arg3 = (bool) true ;
22121 bool result;
22122 void *argp1 = 0 ;
22123 int res1 = 0 ;
22124 bool temp2 = false ;
22125 bool val3 ;
22126 int ecode3 = 0 ;
22127 PyObject * obj0 = 0 ;
22128 PyObject * obj1 = 0 ;
22129 PyObject * obj2 = 0 ;
22130 char * kwnames[] = {
22131 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
22132 };
22133
22134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22136 if (!SWIG_IsOK(res1)) {
22137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22138 }
22139 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22140 {
22141 arg2 = wxString_in_helper(obj1);
22142 if (arg2 == NULL) SWIG_fail;
22143 temp2 = true;
22144 }
22145 if (obj2) {
22146 ecode3 = SWIG_AsVal_bool(obj2, &val3);
22147 if (!SWIG_IsOK(ecode3)) {
22148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
22149 }
22150 arg3 = static_cast< bool >(val3);
22151 }
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 {
22159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22160 }
22161 {
22162 if (temp2)
22163 delete arg2;
22164 }
22165 return resultobj;
22166 fail:
22167 {
22168 if (temp2)
22169 delete arg2;
22170 }
22171 return NULL;
22172 }
22173
22174
22175 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22176 PyObject *resultobj = 0;
22177 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22178 wxString *arg2 = 0 ;
22179 bool result;
22180 void *argp1 = 0 ;
22181 int res1 = 0 ;
22182 bool temp2 = false ;
22183 PyObject * obj0 = 0 ;
22184 PyObject * obj1 = 0 ;
22185 char * kwnames[] = {
22186 (char *) "self",(char *) "key", NULL
22187 };
22188
22189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
22190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22193 }
22194 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22195 {
22196 arg2 = wxString_in_helper(obj1);
22197 if (arg2 == NULL) SWIG_fail;
22198 temp2 = true;
22199 }
22200 {
22201 PyThreadState* __tstate = wxPyBeginAllowThreads();
22202 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
22203 wxPyEndAllowThreads(__tstate);
22204 if (PyErr_Occurred()) SWIG_fail;
22205 }
22206 {
22207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22208 }
22209 {
22210 if (temp2)
22211 delete arg2;
22212 }
22213 return resultobj;
22214 fail:
22215 {
22216 if (temp2)
22217 delete arg2;
22218 }
22219 return NULL;
22220 }
22221
22222
22223 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22224 PyObject *resultobj = 0;
22225 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22226 bool result;
22227 void *argp1 = 0 ;
22228 int res1 = 0 ;
22229 PyObject *swig_obj[1] ;
22230
22231 if (!args) SWIG_fail;
22232 swig_obj[0] = args;
22233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22234 if (!SWIG_IsOK(res1)) {
22235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22236 }
22237 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22238 {
22239 PyThreadState* __tstate = wxPyBeginAllowThreads();
22240 result = (bool)(arg1)->DeleteAll();
22241 wxPyEndAllowThreads(__tstate);
22242 if (PyErr_Occurred()) SWIG_fail;
22243 }
22244 {
22245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22246 }
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22254 PyObject *resultobj = 0;
22255 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22256 bool arg2 = (bool) true ;
22257 void *argp1 = 0 ;
22258 int res1 = 0 ;
22259 bool val2 ;
22260 int ecode2 = 0 ;
22261 PyObject * obj0 = 0 ;
22262 PyObject * obj1 = 0 ;
22263 char * kwnames[] = {
22264 (char *) "self",(char *) "doIt", NULL
22265 };
22266
22267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22269 if (!SWIG_IsOK(res1)) {
22270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22271 }
22272 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22273 if (obj1) {
22274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22275 if (!SWIG_IsOK(ecode2)) {
22276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
22277 }
22278 arg2 = static_cast< bool >(val2);
22279 }
22280 {
22281 PyThreadState* __tstate = wxPyBeginAllowThreads();
22282 (arg1)->SetExpandEnvVars(arg2);
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 resultobj = SWIG_Py_Void();
22287 return resultobj;
22288 fail:
22289 return NULL;
22290 }
22291
22292
22293 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22294 PyObject *resultobj = 0;
22295 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22296 bool result;
22297 void *argp1 = 0 ;
22298 int res1 = 0 ;
22299 PyObject *swig_obj[1] ;
22300
22301 if (!args) SWIG_fail;
22302 swig_obj[0] = args;
22303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22304 if (!SWIG_IsOK(res1)) {
22305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22306 }
22307 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22308 {
22309 PyThreadState* __tstate = wxPyBeginAllowThreads();
22310 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
22311 wxPyEndAllowThreads(__tstate);
22312 if (PyErr_Occurred()) SWIG_fail;
22313 }
22314 {
22315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22316 }
22317 return resultobj;
22318 fail:
22319 return NULL;
22320 }
22321
22322
22323 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22324 PyObject *resultobj = 0;
22325 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22326 bool arg2 = (bool) true ;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 bool val2 ;
22330 int ecode2 = 0 ;
22331 PyObject * obj0 = 0 ;
22332 PyObject * obj1 = 0 ;
22333 char * kwnames[] = {
22334 (char *) "self",(char *) "doIt", NULL
22335 };
22336
22337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
22338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22339 if (!SWIG_IsOK(res1)) {
22340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22341 }
22342 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22343 if (obj1) {
22344 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22345 if (!SWIG_IsOK(ecode2)) {
22346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
22347 }
22348 arg2 = static_cast< bool >(val2);
22349 }
22350 {
22351 PyThreadState* __tstate = wxPyBeginAllowThreads();
22352 (arg1)->SetRecordDefaults(arg2);
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 resultobj = SWIG_Py_Void();
22357 return resultobj;
22358 fail:
22359 return NULL;
22360 }
22361
22362
22363 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22364 PyObject *resultobj = 0;
22365 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22366 bool result;
22367 void *argp1 = 0 ;
22368 int res1 = 0 ;
22369 PyObject *swig_obj[1] ;
22370
22371 if (!args) SWIG_fail;
22372 swig_obj[0] = args;
22373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22374 if (!SWIG_IsOK(res1)) {
22375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22376 }
22377 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22378 {
22379 PyThreadState* __tstate = wxPyBeginAllowThreads();
22380 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
22381 wxPyEndAllowThreads(__tstate);
22382 if (PyErr_Occurred()) SWIG_fail;
22383 }
22384 {
22385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22386 }
22387 return resultobj;
22388 fail:
22389 return NULL;
22390 }
22391
22392
22393 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22394 PyObject *resultobj = 0;
22395 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22396 wxString *arg2 = 0 ;
22397 wxString result;
22398 void *argp1 = 0 ;
22399 int res1 = 0 ;
22400 bool temp2 = false ;
22401 PyObject * obj0 = 0 ;
22402 PyObject * obj1 = 0 ;
22403 char * kwnames[] = {
22404 (char *) "self",(char *) "str", NULL
22405 };
22406
22407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
22408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22409 if (!SWIG_IsOK(res1)) {
22410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22411 }
22412 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22413 {
22414 arg2 = wxString_in_helper(obj1);
22415 if (arg2 == NULL) SWIG_fail;
22416 temp2 = true;
22417 }
22418 {
22419 PyThreadState* __tstate = wxPyBeginAllowThreads();
22420 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 {
22425 #if wxUSE_UNICODE
22426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22427 #else
22428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22429 #endif
22430 }
22431 {
22432 if (temp2)
22433 delete arg2;
22434 }
22435 return resultobj;
22436 fail:
22437 {
22438 if (temp2)
22439 delete arg2;
22440 }
22441 return NULL;
22442 }
22443
22444
22445 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22446 PyObject *resultobj = 0;
22447 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22448 wxString result;
22449 void *argp1 = 0 ;
22450 int res1 = 0 ;
22451 PyObject *swig_obj[1] ;
22452
22453 if (!args) SWIG_fail;
22454 swig_obj[0] = args;
22455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22456 if (!SWIG_IsOK(res1)) {
22457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22458 }
22459 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22460 {
22461 PyThreadState* __tstate = wxPyBeginAllowThreads();
22462 result = ((wxConfigBase const *)arg1)->GetAppName();
22463 wxPyEndAllowThreads(__tstate);
22464 if (PyErr_Occurred()) SWIG_fail;
22465 }
22466 {
22467 #if wxUSE_UNICODE
22468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22469 #else
22470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22471 #endif
22472 }
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22480 PyObject *resultobj = 0;
22481 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22482 wxString result;
22483 void *argp1 = 0 ;
22484 int res1 = 0 ;
22485 PyObject *swig_obj[1] ;
22486
22487 if (!args) SWIG_fail;
22488 swig_obj[0] = args;
22489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22492 }
22493 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22494 {
22495 PyThreadState* __tstate = wxPyBeginAllowThreads();
22496 result = ((wxConfigBase const *)arg1)->GetVendorName();
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 {
22501 #if wxUSE_UNICODE
22502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22503 #else
22504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22505 #endif
22506 }
22507 return resultobj;
22508 fail:
22509 return NULL;
22510 }
22511
22512
22513 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22514 PyObject *resultobj = 0;
22515 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22516 wxString *arg2 = 0 ;
22517 void *argp1 = 0 ;
22518 int res1 = 0 ;
22519 bool temp2 = false ;
22520 PyObject * obj0 = 0 ;
22521 PyObject * obj1 = 0 ;
22522 char * kwnames[] = {
22523 (char *) "self",(char *) "appName", NULL
22524 };
22525
22526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
22527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22528 if (!SWIG_IsOK(res1)) {
22529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22530 }
22531 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22532 {
22533 arg2 = wxString_in_helper(obj1);
22534 if (arg2 == NULL) SWIG_fail;
22535 temp2 = true;
22536 }
22537 {
22538 PyThreadState* __tstate = wxPyBeginAllowThreads();
22539 (arg1)->SetAppName((wxString const &)*arg2);
22540 wxPyEndAllowThreads(__tstate);
22541 if (PyErr_Occurred()) SWIG_fail;
22542 }
22543 resultobj = SWIG_Py_Void();
22544 {
22545 if (temp2)
22546 delete arg2;
22547 }
22548 return resultobj;
22549 fail:
22550 {
22551 if (temp2)
22552 delete arg2;
22553 }
22554 return NULL;
22555 }
22556
22557
22558 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22559 PyObject *resultobj = 0;
22560 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22561 wxString *arg2 = 0 ;
22562 void *argp1 = 0 ;
22563 int res1 = 0 ;
22564 bool temp2 = false ;
22565 PyObject * obj0 = 0 ;
22566 PyObject * obj1 = 0 ;
22567 char * kwnames[] = {
22568 (char *) "self",(char *) "vendorName", NULL
22569 };
22570
22571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
22572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22573 if (!SWIG_IsOK(res1)) {
22574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22575 }
22576 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22577 {
22578 arg2 = wxString_in_helper(obj1);
22579 if (arg2 == NULL) SWIG_fail;
22580 temp2 = true;
22581 }
22582 {
22583 PyThreadState* __tstate = wxPyBeginAllowThreads();
22584 (arg1)->SetVendorName((wxString const &)*arg2);
22585 wxPyEndAllowThreads(__tstate);
22586 if (PyErr_Occurred()) SWIG_fail;
22587 }
22588 resultobj = SWIG_Py_Void();
22589 {
22590 if (temp2)
22591 delete arg2;
22592 }
22593 return resultobj;
22594 fail:
22595 {
22596 if (temp2)
22597 delete arg2;
22598 }
22599 return NULL;
22600 }
22601
22602
22603 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22604 PyObject *resultobj = 0;
22605 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22606 long arg2 ;
22607 void *argp1 = 0 ;
22608 int res1 = 0 ;
22609 long val2 ;
22610 int ecode2 = 0 ;
22611 PyObject * obj0 = 0 ;
22612 PyObject * obj1 = 0 ;
22613 char * kwnames[] = {
22614 (char *) "self",(char *) "style", NULL
22615 };
22616
22617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
22618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
22621 }
22622 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22623 ecode2 = SWIG_AsVal_long(obj1, &val2);
22624 if (!SWIG_IsOK(ecode2)) {
22625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
22626 }
22627 arg2 = static_cast< long >(val2);
22628 {
22629 PyThreadState* __tstate = wxPyBeginAllowThreads();
22630 (arg1)->SetStyle(arg2);
22631 wxPyEndAllowThreads(__tstate);
22632 if (PyErr_Occurred()) SWIG_fail;
22633 }
22634 resultobj = SWIG_Py_Void();
22635 return resultobj;
22636 fail:
22637 return NULL;
22638 }
22639
22640
22641 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22642 PyObject *resultobj = 0;
22643 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22644 long result;
22645 void *argp1 = 0 ;
22646 int res1 = 0 ;
22647 PyObject *swig_obj[1] ;
22648
22649 if (!args) SWIG_fail;
22650 swig_obj[0] = args;
22651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22652 if (!SWIG_IsOK(res1)) {
22653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22654 }
22655 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22656 {
22657 PyThreadState* __tstate = wxPyBeginAllowThreads();
22658 result = (long)((wxConfigBase const *)arg1)->GetStyle();
22659 wxPyEndAllowThreads(__tstate);
22660 if (PyErr_Occurred()) SWIG_fail;
22661 }
22662 resultobj = SWIG_From_long(static_cast< long >(result));
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22670 PyObject *obj;
22671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22672 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
22673 return SWIG_Py_Void();
22674 }
22675
22676 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22677 PyObject *resultobj = 0;
22678 wxString const &arg1_defvalue = wxPyEmptyString ;
22679 wxString *arg1 = (wxString *) &arg1_defvalue ;
22680 wxString const &arg2_defvalue = wxPyEmptyString ;
22681 wxString *arg2 = (wxString *) &arg2_defvalue ;
22682 wxString const &arg3_defvalue = wxPyEmptyString ;
22683 wxString *arg3 = (wxString *) &arg3_defvalue ;
22684 wxString const &arg4_defvalue = wxPyEmptyString ;
22685 wxString *arg4 = (wxString *) &arg4_defvalue ;
22686 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22687 wxConfig *result = 0 ;
22688 bool temp1 = false ;
22689 bool temp2 = false ;
22690 bool temp3 = false ;
22691 bool temp4 = false ;
22692 long val5 ;
22693 int ecode5 = 0 ;
22694 PyObject * obj0 = 0 ;
22695 PyObject * obj1 = 0 ;
22696 PyObject * obj2 = 0 ;
22697 PyObject * obj3 = 0 ;
22698 PyObject * obj4 = 0 ;
22699 char * kwnames[] = {
22700 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22701 };
22702
22703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22704 if (obj0) {
22705 {
22706 arg1 = wxString_in_helper(obj0);
22707 if (arg1 == NULL) SWIG_fail;
22708 temp1 = true;
22709 }
22710 }
22711 if (obj1) {
22712 {
22713 arg2 = wxString_in_helper(obj1);
22714 if (arg2 == NULL) SWIG_fail;
22715 temp2 = true;
22716 }
22717 }
22718 if (obj2) {
22719 {
22720 arg3 = wxString_in_helper(obj2);
22721 if (arg3 == NULL) SWIG_fail;
22722 temp3 = true;
22723 }
22724 }
22725 if (obj3) {
22726 {
22727 arg4 = wxString_in_helper(obj3);
22728 if (arg4 == NULL) SWIG_fail;
22729 temp4 = true;
22730 }
22731 }
22732 if (obj4) {
22733 ecode5 = SWIG_AsVal_long(obj4, &val5);
22734 if (!SWIG_IsOK(ecode5)) {
22735 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
22736 }
22737 arg5 = static_cast< long >(val5);
22738 }
22739 {
22740 PyThreadState* __tstate = wxPyBeginAllowThreads();
22741 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22742 wxPyEndAllowThreads(__tstate);
22743 if (PyErr_Occurred()) SWIG_fail;
22744 }
22745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
22746 {
22747 if (temp1)
22748 delete arg1;
22749 }
22750 {
22751 if (temp2)
22752 delete arg2;
22753 }
22754 {
22755 if (temp3)
22756 delete arg3;
22757 }
22758 {
22759 if (temp4)
22760 delete arg4;
22761 }
22762 return resultobj;
22763 fail:
22764 {
22765 if (temp1)
22766 delete arg1;
22767 }
22768 {
22769 if (temp2)
22770 delete arg2;
22771 }
22772 {
22773 if (temp3)
22774 delete arg3;
22775 }
22776 {
22777 if (temp4)
22778 delete arg4;
22779 }
22780 return NULL;
22781 }
22782
22783
22784 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22785 PyObject *resultobj = 0;
22786 wxConfig *arg1 = (wxConfig *) 0 ;
22787 void *argp1 = 0 ;
22788 int res1 = 0 ;
22789 PyObject *swig_obj[1] ;
22790
22791 if (!args) SWIG_fail;
22792 swig_obj[0] = args;
22793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
22794 if (!SWIG_IsOK(res1)) {
22795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
22796 }
22797 arg1 = reinterpret_cast< wxConfig * >(argp1);
22798 {
22799 PyThreadState* __tstate = wxPyBeginAllowThreads();
22800 delete arg1;
22801
22802 wxPyEndAllowThreads(__tstate);
22803 if (PyErr_Occurred()) SWIG_fail;
22804 }
22805 resultobj = SWIG_Py_Void();
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22813 PyObject *obj;
22814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22815 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
22816 return SWIG_Py_Void();
22817 }
22818
22819 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22820 return SWIG_Python_InitShadowInstance(args);
22821 }
22822
22823 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22824 PyObject *resultobj = 0;
22825 wxString const &arg1_defvalue = wxPyEmptyString ;
22826 wxString *arg1 = (wxString *) &arg1_defvalue ;
22827 wxString const &arg2_defvalue = wxPyEmptyString ;
22828 wxString *arg2 = (wxString *) &arg2_defvalue ;
22829 wxString const &arg3_defvalue = wxPyEmptyString ;
22830 wxString *arg3 = (wxString *) &arg3_defvalue ;
22831 wxString const &arg4_defvalue = wxPyEmptyString ;
22832 wxString *arg4 = (wxString *) &arg4_defvalue ;
22833 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
22834 wxFileConfig *result = 0 ;
22835 bool temp1 = false ;
22836 bool temp2 = false ;
22837 bool temp3 = false ;
22838 bool temp4 = false ;
22839 long val5 ;
22840 int ecode5 = 0 ;
22841 PyObject * obj0 = 0 ;
22842 PyObject * obj1 = 0 ;
22843 PyObject * obj2 = 0 ;
22844 PyObject * obj3 = 0 ;
22845 PyObject * obj4 = 0 ;
22846 char * kwnames[] = {
22847 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
22848 };
22849
22850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22851 if (obj0) {
22852 {
22853 arg1 = wxString_in_helper(obj0);
22854 if (arg1 == NULL) SWIG_fail;
22855 temp1 = true;
22856 }
22857 }
22858 if (obj1) {
22859 {
22860 arg2 = wxString_in_helper(obj1);
22861 if (arg2 == NULL) SWIG_fail;
22862 temp2 = true;
22863 }
22864 }
22865 if (obj2) {
22866 {
22867 arg3 = wxString_in_helper(obj2);
22868 if (arg3 == NULL) SWIG_fail;
22869 temp3 = true;
22870 }
22871 }
22872 if (obj3) {
22873 {
22874 arg4 = wxString_in_helper(obj3);
22875 if (arg4 == NULL) SWIG_fail;
22876 temp4 = true;
22877 }
22878 }
22879 if (obj4) {
22880 ecode5 = SWIG_AsVal_long(obj4, &val5);
22881 if (!SWIG_IsOK(ecode5)) {
22882 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
22883 }
22884 arg5 = static_cast< long >(val5);
22885 }
22886 {
22887 PyThreadState* __tstate = wxPyBeginAllowThreads();
22888 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
22889 wxPyEndAllowThreads(__tstate);
22890 if (PyErr_Occurred()) SWIG_fail;
22891 }
22892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
22893 {
22894 if (temp1)
22895 delete arg1;
22896 }
22897 {
22898 if (temp2)
22899 delete arg2;
22900 }
22901 {
22902 if (temp3)
22903 delete arg3;
22904 }
22905 {
22906 if (temp4)
22907 delete arg4;
22908 }
22909 return resultobj;
22910 fail:
22911 {
22912 if (temp1)
22913 delete arg1;
22914 }
22915 {
22916 if (temp2)
22917 delete arg2;
22918 }
22919 {
22920 if (temp3)
22921 delete arg3;
22922 }
22923 {
22924 if (temp4)
22925 delete arg4;
22926 }
22927 return NULL;
22928 }
22929
22930
22931 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22932 PyObject *resultobj = 0;
22933 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
22934 void *argp1 = 0 ;
22935 int res1 = 0 ;
22936 PyObject *swig_obj[1] ;
22937
22938 if (!args) SWIG_fail;
22939 swig_obj[0] = args;
22940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
22941 if (!SWIG_IsOK(res1)) {
22942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
22943 }
22944 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 delete arg1;
22948
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 resultobj = SWIG_Py_Void();
22953 return resultobj;
22954 fail:
22955 return NULL;
22956 }
22957
22958
22959 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22960 PyObject *obj;
22961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22962 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
22963 return SWIG_Py_Void();
22964 }
22965
22966 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22967 return SWIG_Python_InitShadowInstance(args);
22968 }
22969
22970 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22971 PyObject *resultobj = 0;
22972 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
22973 wxString *arg2 = 0 ;
22974 wxConfigPathChanger *result = 0 ;
22975 void *argp1 = 0 ;
22976 int res1 = 0 ;
22977 bool temp2 = false ;
22978 PyObject * obj0 = 0 ;
22979 PyObject * obj1 = 0 ;
22980 char * kwnames[] = {
22981 (char *) "config",(char *) "entry", NULL
22982 };
22983
22984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
22985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
22986 if (!SWIG_IsOK(res1)) {
22987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
22988 }
22989 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
22990 {
22991 arg2 = wxString_in_helper(obj1);
22992 if (arg2 == NULL) SWIG_fail;
22993 temp2 = true;
22994 }
22995 {
22996 PyThreadState* __tstate = wxPyBeginAllowThreads();
22997 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
22998 wxPyEndAllowThreads(__tstate);
22999 if (PyErr_Occurred()) SWIG_fail;
23000 }
23001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
23002 {
23003 if (temp2)
23004 delete arg2;
23005 }
23006 return resultobj;
23007 fail:
23008 {
23009 if (temp2)
23010 delete arg2;
23011 }
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23017 PyObject *resultobj = 0;
23018 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23019 void *argp1 = 0 ;
23020 int res1 = 0 ;
23021 PyObject *swig_obj[1] ;
23022
23023 if (!args) SWIG_fail;
23024 swig_obj[0] = args;
23025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
23026 if (!SWIG_IsOK(res1)) {
23027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
23028 }
23029 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23030 {
23031 PyThreadState* __tstate = wxPyBeginAllowThreads();
23032 delete arg1;
23033
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 resultobj = SWIG_Py_Void();
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23045 PyObject *resultobj = 0;
23046 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
23047 wxString *result = 0 ;
23048 void *argp1 = 0 ;
23049 int res1 = 0 ;
23050 PyObject *swig_obj[1] ;
23051
23052 if (!args) SWIG_fail;
23053 swig_obj[0] = args;
23054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
23055 if (!SWIG_IsOK(res1)) {
23056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
23057 }
23058 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
23059 {
23060 PyThreadState* __tstate = wxPyBeginAllowThreads();
23061 {
23062 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
23063 result = (wxString *) &_result_ref;
23064 }
23065 wxPyEndAllowThreads(__tstate);
23066 if (PyErr_Occurred()) SWIG_fail;
23067 }
23068 {
23069 #if wxUSE_UNICODE
23070 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23071 #else
23072 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23073 #endif
23074 }
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *obj;
23083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23084 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
23085 return SWIG_Py_Void();
23086 }
23087
23088 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23089 return SWIG_Python_InitShadowInstance(args);
23090 }
23091
23092 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23093 PyObject *resultobj = 0;
23094 wxString *arg1 = 0 ;
23095 wxString result;
23096 bool temp1 = false ;
23097 PyObject * obj0 = 0 ;
23098 char * kwnames[] = {
23099 (char *) "sz", NULL
23100 };
23101
23102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
23103 {
23104 arg1 = wxString_in_helper(obj0);
23105 if (arg1 == NULL) SWIG_fail;
23106 temp1 = true;
23107 }
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 result = wxExpandEnvVars((wxString const &)*arg1);
23111 wxPyEndAllowThreads(__tstate);
23112 if (PyErr_Occurred()) SWIG_fail;
23113 }
23114 {
23115 #if wxUSE_UNICODE
23116 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23117 #else
23118 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23119 #endif
23120 }
23121 {
23122 if (temp1)
23123 delete arg1;
23124 }
23125 return resultobj;
23126 fail:
23127 {
23128 if (temp1)
23129 delete arg1;
23130 }
23131 return NULL;
23132 }
23133
23134
23135 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
23136 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
23137 return 1;
23138 }
23139
23140
23141 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
23142 PyObject *pyobj = 0;
23143
23144 {
23145 #if wxUSE_UNICODE
23146 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23147 #else
23148 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
23149 #endif
23150 }
23151 return pyobj;
23152 }
23153
23154
23155 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
23156 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
23157 return 1;
23158 }
23159
23160
23161 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
23162 PyObject *pyobj = 0;
23163
23164 {
23165 #if wxUSE_UNICODE
23166 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23167 #else
23168 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
23169 #endif
23170 }
23171 return pyobj;
23172 }
23173
23174
23175 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23176 PyObject *resultobj = 0;
23177 wxDateTime::Country arg1 ;
23178 int val1 ;
23179 int ecode1 = 0 ;
23180 PyObject * obj0 = 0 ;
23181 char * kwnames[] = {
23182 (char *) "country", NULL
23183 };
23184
23185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
23186 ecode1 = SWIG_AsVal_int(obj0, &val1);
23187 if (!SWIG_IsOK(ecode1)) {
23188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23189 }
23190 arg1 = static_cast< wxDateTime::Country >(val1);
23191 {
23192 PyThreadState* __tstate = wxPyBeginAllowThreads();
23193 wxDateTime::SetCountry(arg1);
23194 wxPyEndAllowThreads(__tstate);
23195 if (PyErr_Occurred()) SWIG_fail;
23196 }
23197 resultobj = SWIG_Py_Void();
23198 return resultobj;
23199 fail:
23200 return NULL;
23201 }
23202
23203
23204 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23205 PyObject *resultobj = 0;
23206 wxDateTime::Country result;
23207
23208 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
23209 {
23210 PyThreadState* __tstate = wxPyBeginAllowThreads();
23211 result = (wxDateTime::Country)wxDateTime::GetCountry();
23212 wxPyEndAllowThreads(__tstate);
23213 if (PyErr_Occurred()) SWIG_fail;
23214 }
23215 resultobj = SWIG_From_int(static_cast< int >(result));
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23223 PyObject *resultobj = 0;
23224 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
23225 bool result;
23226 int val1 ;
23227 int ecode1 = 0 ;
23228 PyObject * obj0 = 0 ;
23229 char * kwnames[] = {
23230 (char *) "country", NULL
23231 };
23232
23233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
23234 if (obj0) {
23235 ecode1 = SWIG_AsVal_int(obj0, &val1);
23236 if (!SWIG_IsOK(ecode1)) {
23237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
23238 }
23239 arg1 = static_cast< wxDateTime::Country >(val1);
23240 }
23241 {
23242 PyThreadState* __tstate = wxPyBeginAllowThreads();
23243 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
23244 wxPyEndAllowThreads(__tstate);
23245 if (PyErr_Occurred()) SWIG_fail;
23246 }
23247 {
23248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23249 }
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj = 0;
23258 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23259 int result;
23260 int val1 ;
23261 int ecode1 = 0 ;
23262 PyObject * obj0 = 0 ;
23263 char * kwnames[] = {
23264 (char *) "cal", NULL
23265 };
23266
23267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
23268 if (obj0) {
23269 ecode1 = SWIG_AsVal_int(obj0, &val1);
23270 if (!SWIG_IsOK(ecode1)) {
23271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23272 }
23273 arg1 = static_cast< wxDateTime::Calendar >(val1);
23274 }
23275 {
23276 PyThreadState* __tstate = wxPyBeginAllowThreads();
23277 result = (int)wxDateTime::GetCurrentYear(arg1);
23278 wxPyEndAllowThreads(__tstate);
23279 if (PyErr_Occurred()) SWIG_fail;
23280 }
23281 resultobj = SWIG_From_int(static_cast< int >(result));
23282 return resultobj;
23283 fail:
23284 return NULL;
23285 }
23286
23287
23288 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23289 PyObject *resultobj = 0;
23290 int arg1 ;
23291 int result;
23292 int val1 ;
23293 int ecode1 = 0 ;
23294 PyObject * obj0 = 0 ;
23295 char * kwnames[] = {
23296 (char *) "year", NULL
23297 };
23298
23299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
23300 ecode1 = SWIG_AsVal_int(obj0, &val1);
23301 if (!SWIG_IsOK(ecode1)) {
23302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
23303 }
23304 arg1 = static_cast< int >(val1);
23305 {
23306 PyThreadState* __tstate = wxPyBeginAllowThreads();
23307 result = (int)wxDateTime::ConvertYearToBC(arg1);
23308 wxPyEndAllowThreads(__tstate);
23309 if (PyErr_Occurred()) SWIG_fail;
23310 }
23311 resultobj = SWIG_From_int(static_cast< int >(result));
23312 return resultobj;
23313 fail:
23314 return NULL;
23315 }
23316
23317
23318 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23319 PyObject *resultobj = 0;
23320 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23321 wxDateTime::Month result;
23322 int val1 ;
23323 int ecode1 = 0 ;
23324 PyObject * obj0 = 0 ;
23325 char * kwnames[] = {
23326 (char *) "cal", NULL
23327 };
23328
23329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
23330 if (obj0) {
23331 ecode1 = SWIG_AsVal_int(obj0, &val1);
23332 if (!SWIG_IsOK(ecode1)) {
23333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
23334 }
23335 arg1 = static_cast< wxDateTime::Calendar >(val1);
23336 }
23337 {
23338 PyThreadState* __tstate = wxPyBeginAllowThreads();
23339 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
23340 wxPyEndAllowThreads(__tstate);
23341 if (PyErr_Occurred()) SWIG_fail;
23342 }
23343 resultobj = SWIG_From_int(static_cast< int >(result));
23344 return resultobj;
23345 fail:
23346 return NULL;
23347 }
23348
23349
23350 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23351 PyObject *resultobj = 0;
23352 int arg1 = (int) wxDateTime::Inv_Year ;
23353 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23354 bool result;
23355 int val1 ;
23356 int ecode1 = 0 ;
23357 int val2 ;
23358 int ecode2 = 0 ;
23359 PyObject * obj0 = 0 ;
23360 PyObject * obj1 = 0 ;
23361 char * kwnames[] = {
23362 (char *) "year",(char *) "cal", NULL
23363 };
23364
23365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
23366 if (obj0) {
23367 ecode1 = SWIG_AsVal_int(obj0, &val1);
23368 if (!SWIG_IsOK(ecode1)) {
23369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
23370 }
23371 arg1 = static_cast< int >(val1);
23372 }
23373 if (obj1) {
23374 ecode2 = SWIG_AsVal_int(obj1, &val2);
23375 if (!SWIG_IsOK(ecode2)) {
23376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23377 }
23378 arg2 = static_cast< wxDateTime::Calendar >(val2);
23379 }
23380 {
23381 PyThreadState* __tstate = wxPyBeginAllowThreads();
23382 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
23383 wxPyEndAllowThreads(__tstate);
23384 if (PyErr_Occurred()) SWIG_fail;
23385 }
23386 {
23387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23388 }
23389 return resultobj;
23390 fail:
23391 return NULL;
23392 }
23393
23394
23395 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23396 PyObject *resultobj = 0;
23397 int arg1 = (int) wxDateTime::Inv_Year ;
23398 int result;
23399 int val1 ;
23400 int ecode1 = 0 ;
23401 PyObject * obj0 = 0 ;
23402 char * kwnames[] = {
23403 (char *) "year", NULL
23404 };
23405
23406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
23407 if (obj0) {
23408 ecode1 = SWIG_AsVal_int(obj0, &val1);
23409 if (!SWIG_IsOK(ecode1)) {
23410 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
23411 }
23412 arg1 = static_cast< int >(val1);
23413 }
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 result = (int)wxDateTime::GetCentury(arg1);
23417 wxPyEndAllowThreads(__tstate);
23418 if (PyErr_Occurred()) SWIG_fail;
23419 }
23420 resultobj = SWIG_From_int(static_cast< int >(result));
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23428 PyObject *resultobj = 0;
23429 int arg1 ;
23430 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23431 int result;
23432 int val1 ;
23433 int ecode1 = 0 ;
23434 int val2 ;
23435 int ecode2 = 0 ;
23436 PyObject * obj0 = 0 ;
23437 PyObject * obj1 = 0 ;
23438 char * kwnames[] = {
23439 (char *) "year",(char *) "cal", NULL
23440 };
23441
23442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
23443 ecode1 = SWIG_AsVal_int(obj0, &val1);
23444 if (!SWIG_IsOK(ecode1)) {
23445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
23446 }
23447 arg1 = static_cast< int >(val1);
23448 if (obj1) {
23449 ecode2 = SWIG_AsVal_int(obj1, &val2);
23450 if (!SWIG_IsOK(ecode2)) {
23451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
23452 }
23453 arg2 = static_cast< wxDateTime::Calendar >(val2);
23454 }
23455 {
23456 PyThreadState* __tstate = wxPyBeginAllowThreads();
23457 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
23458 wxPyEndAllowThreads(__tstate);
23459 if (PyErr_Occurred()) SWIG_fail;
23460 }
23461 resultobj = SWIG_From_int(static_cast< int >(result));
23462 return resultobj;
23463 fail:
23464 return NULL;
23465 }
23466
23467
23468 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23469 PyObject *resultobj = 0;
23470 wxDateTime::Month arg1 ;
23471 int arg2 = (int) wxDateTime::Inv_Year ;
23472 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
23473 int result;
23474 int val1 ;
23475 int ecode1 = 0 ;
23476 int val2 ;
23477 int ecode2 = 0 ;
23478 int val3 ;
23479 int ecode3 = 0 ;
23480 PyObject * obj0 = 0 ;
23481 PyObject * obj1 = 0 ;
23482 PyObject * obj2 = 0 ;
23483 char * kwnames[] = {
23484 (char *) "month",(char *) "year",(char *) "cal", NULL
23485 };
23486
23487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23488 ecode1 = SWIG_AsVal_int(obj0, &val1);
23489 if (!SWIG_IsOK(ecode1)) {
23490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23491 }
23492 arg1 = static_cast< wxDateTime::Month >(val1);
23493 if (obj1) {
23494 ecode2 = SWIG_AsVal_int(obj1, &val2);
23495 if (!SWIG_IsOK(ecode2)) {
23496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
23497 }
23498 arg2 = static_cast< int >(val2);
23499 }
23500 if (obj2) {
23501 ecode3 = SWIG_AsVal_int(obj2, &val3);
23502 if (!SWIG_IsOK(ecode3)) {
23503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
23504 }
23505 arg3 = static_cast< wxDateTime::Calendar >(val3);
23506 }
23507 {
23508 PyThreadState* __tstate = wxPyBeginAllowThreads();
23509 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 resultobj = SWIG_From_int(static_cast< int >(result));
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj = 0;
23522 wxDateTime::Month arg1 ;
23523 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23524 wxString result;
23525 int val1 ;
23526 int ecode1 = 0 ;
23527 int val2 ;
23528 int ecode2 = 0 ;
23529 PyObject * obj0 = 0 ;
23530 PyObject * obj1 = 0 ;
23531 char * kwnames[] = {
23532 (char *) "month",(char *) "flags", NULL
23533 };
23534
23535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
23536 ecode1 = SWIG_AsVal_int(obj0, &val1);
23537 if (!SWIG_IsOK(ecode1)) {
23538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
23539 }
23540 arg1 = static_cast< wxDateTime::Month >(val1);
23541 if (obj1) {
23542 ecode2 = SWIG_AsVal_int(obj1, &val2);
23543 if (!SWIG_IsOK(ecode2)) {
23544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23545 }
23546 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23547 }
23548 {
23549 PyThreadState* __tstate = wxPyBeginAllowThreads();
23550 result = wxDateTime::GetMonthName(arg1,arg2);
23551 wxPyEndAllowThreads(__tstate);
23552 if (PyErr_Occurred()) SWIG_fail;
23553 }
23554 {
23555 #if wxUSE_UNICODE
23556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23557 #else
23558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23559 #endif
23560 }
23561 return resultobj;
23562 fail:
23563 return NULL;
23564 }
23565
23566
23567 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23568 PyObject *resultobj = 0;
23569 wxDateTime::WeekDay arg1 ;
23570 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
23571 wxString result;
23572 int val1 ;
23573 int ecode1 = 0 ;
23574 int val2 ;
23575 int ecode2 = 0 ;
23576 PyObject * obj0 = 0 ;
23577 PyObject * obj1 = 0 ;
23578 char * kwnames[] = {
23579 (char *) "weekday",(char *) "flags", NULL
23580 };
23581
23582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
23583 ecode1 = SWIG_AsVal_int(obj0, &val1);
23584 if (!SWIG_IsOK(ecode1)) {
23585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
23586 }
23587 arg1 = static_cast< wxDateTime::WeekDay >(val1);
23588 if (obj1) {
23589 ecode2 = SWIG_AsVal_int(obj1, &val2);
23590 if (!SWIG_IsOK(ecode2)) {
23591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
23592 }
23593 arg2 = static_cast< wxDateTime::NameFlags >(val2);
23594 }
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 result = wxDateTime::GetWeekDayName(arg1,arg2);
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 {
23602 #if wxUSE_UNICODE
23603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23604 #else
23605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23606 #endif
23607 }
23608 return resultobj;
23609 fail:
23610 return NULL;
23611 }
23612
23613
23614 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23615 PyObject *resultobj = 0;
23616 PyObject *result = 0 ;
23617
23618 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
23619 {
23620 PyThreadState* __tstate = wxPyBeginAllowThreads();
23621 result = (PyObject *)wxDateTime_GetAmPmStrings();
23622 wxPyEndAllowThreads(__tstate);
23623 if (PyErr_Occurred()) SWIG_fail;
23624 }
23625 resultobj = result;
23626 return resultobj;
23627 fail:
23628 return NULL;
23629 }
23630
23631
23632 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23633 PyObject *resultobj = 0;
23634 int arg1 = (int) wxDateTime::Inv_Year ;
23635 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23636 bool result;
23637 int val1 ;
23638 int ecode1 = 0 ;
23639 int val2 ;
23640 int ecode2 = 0 ;
23641 PyObject * obj0 = 0 ;
23642 PyObject * obj1 = 0 ;
23643 char * kwnames[] = {
23644 (char *) "year",(char *) "country", NULL
23645 };
23646
23647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
23648 if (obj0) {
23649 ecode1 = SWIG_AsVal_int(obj0, &val1);
23650 if (!SWIG_IsOK(ecode1)) {
23651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
23652 }
23653 arg1 = static_cast< int >(val1);
23654 }
23655 if (obj1) {
23656 ecode2 = SWIG_AsVal_int(obj1, &val2);
23657 if (!SWIG_IsOK(ecode2)) {
23658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23659 }
23660 arg2 = static_cast< wxDateTime::Country >(val2);
23661 }
23662 {
23663 PyThreadState* __tstate = wxPyBeginAllowThreads();
23664 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 {
23669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23670 }
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23678 PyObject *resultobj = 0;
23679 int arg1 = (int) wxDateTime::Inv_Year ;
23680 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23681 wxDateTime result;
23682 int val1 ;
23683 int ecode1 = 0 ;
23684 int val2 ;
23685 int ecode2 = 0 ;
23686 PyObject * obj0 = 0 ;
23687 PyObject * obj1 = 0 ;
23688 char * kwnames[] = {
23689 (char *) "year",(char *) "country", NULL
23690 };
23691
23692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
23693 if (obj0) {
23694 ecode1 = SWIG_AsVal_int(obj0, &val1);
23695 if (!SWIG_IsOK(ecode1)) {
23696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
23697 }
23698 arg1 = static_cast< int >(val1);
23699 }
23700 if (obj1) {
23701 ecode2 = SWIG_AsVal_int(obj1, &val2);
23702 if (!SWIG_IsOK(ecode2)) {
23703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23704 }
23705 arg2 = static_cast< wxDateTime::Country >(val2);
23706 }
23707 {
23708 PyThreadState* __tstate = wxPyBeginAllowThreads();
23709 result = wxDateTime::GetBeginDST(arg1,arg2);
23710 wxPyEndAllowThreads(__tstate);
23711 if (PyErr_Occurred()) SWIG_fail;
23712 }
23713 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23714 return resultobj;
23715 fail:
23716 return NULL;
23717 }
23718
23719
23720 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23721 PyObject *resultobj = 0;
23722 int arg1 = (int) wxDateTime::Inv_Year ;
23723 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
23724 wxDateTime result;
23725 int val1 ;
23726 int ecode1 = 0 ;
23727 int val2 ;
23728 int ecode2 = 0 ;
23729 PyObject * obj0 = 0 ;
23730 PyObject * obj1 = 0 ;
23731 char * kwnames[] = {
23732 (char *) "year",(char *) "country", NULL
23733 };
23734
23735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
23736 if (obj0) {
23737 ecode1 = SWIG_AsVal_int(obj0, &val1);
23738 if (!SWIG_IsOK(ecode1)) {
23739 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
23740 }
23741 arg1 = static_cast< int >(val1);
23742 }
23743 if (obj1) {
23744 ecode2 = SWIG_AsVal_int(obj1, &val2);
23745 if (!SWIG_IsOK(ecode2)) {
23746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
23747 }
23748 arg2 = static_cast< wxDateTime::Country >(val2);
23749 }
23750 {
23751 PyThreadState* __tstate = wxPyBeginAllowThreads();
23752 result = wxDateTime::GetEndDST(arg1,arg2);
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23757 return resultobj;
23758 fail:
23759 return NULL;
23760 }
23761
23762
23763 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23764 PyObject *resultobj = 0;
23765 wxDateTime result;
23766
23767 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
23768 {
23769 PyThreadState* __tstate = wxPyBeginAllowThreads();
23770 result = wxDateTime::Now();
23771 wxPyEndAllowThreads(__tstate);
23772 if (PyErr_Occurred()) SWIG_fail;
23773 }
23774 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23775 return resultobj;
23776 fail:
23777 return NULL;
23778 }
23779
23780
23781 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23782 PyObject *resultobj = 0;
23783 wxDateTime result;
23784
23785 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
23786 {
23787 PyThreadState* __tstate = wxPyBeginAllowThreads();
23788 result = wxDateTime::UNow();
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23800 PyObject *resultobj = 0;
23801 wxDateTime result;
23802
23803 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
23804 {
23805 PyThreadState* __tstate = wxPyBeginAllowThreads();
23806 result = wxDateTime::Today();
23807 wxPyEndAllowThreads(__tstate);
23808 if (PyErr_Occurred()) SWIG_fail;
23809 }
23810 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23811 return resultobj;
23812 fail:
23813 return NULL;
23814 }
23815
23816
23817 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23818 PyObject *resultobj = 0;
23819 wxDateTime *result = 0 ;
23820
23821 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
23822 {
23823 PyThreadState* __tstate = wxPyBeginAllowThreads();
23824 result = (wxDateTime *)new wxDateTime();
23825 wxPyEndAllowThreads(__tstate);
23826 if (PyErr_Occurred()) SWIG_fail;
23827 }
23828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
23829 return resultobj;
23830 fail:
23831 return NULL;
23832 }
23833
23834
23835 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23836 PyObject *resultobj = 0;
23837 time_t arg1 ;
23838 wxDateTime *result = 0 ;
23839 unsigned int val1 ;
23840 int ecode1 = 0 ;
23841 PyObject * obj0 = 0 ;
23842 char * kwnames[] = {
23843 (char *) "timet", NULL
23844 };
23845
23846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
23847 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
23848 if (!SWIG_IsOK(ecode1)) {
23849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
23850 }
23851 arg1 = static_cast< time_t >(val1);
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = (wxDateTime *)new wxDateTime(arg1);
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23866 PyObject *resultobj = 0;
23867 double arg1 ;
23868 wxDateTime *result = 0 ;
23869 double val1 ;
23870 int ecode1 = 0 ;
23871 PyObject * obj0 = 0 ;
23872 char * kwnames[] = {
23873 (char *) "jdn", NULL
23874 };
23875
23876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
23877 ecode1 = SWIG_AsVal_double(obj0, &val1);
23878 if (!SWIG_IsOK(ecode1)) {
23879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
23880 }
23881 arg1 = static_cast< double >(val1);
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (wxDateTime *)new wxDateTime(arg1);
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj = 0;
23897 int arg1 ;
23898 int arg2 = (int) 0 ;
23899 int arg3 = (int) 0 ;
23900 int arg4 = (int) 0 ;
23901 wxDateTime *result = 0 ;
23902 int val1 ;
23903 int ecode1 = 0 ;
23904 int val2 ;
23905 int ecode2 = 0 ;
23906 int val3 ;
23907 int ecode3 = 0 ;
23908 int val4 ;
23909 int ecode4 = 0 ;
23910 PyObject * obj0 = 0 ;
23911 PyObject * obj1 = 0 ;
23912 PyObject * obj2 = 0 ;
23913 PyObject * obj3 = 0 ;
23914 char * kwnames[] = {
23915 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23916 };
23917
23918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23919 ecode1 = SWIG_AsVal_int(obj0, &val1);
23920 if (!SWIG_IsOK(ecode1)) {
23921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
23922 }
23923 arg1 = static_cast< int >(val1);
23924 if (obj1) {
23925 ecode2 = SWIG_AsVal_int(obj1, &val2);
23926 if (!SWIG_IsOK(ecode2)) {
23927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
23928 }
23929 arg2 = static_cast< int >(val2);
23930 }
23931 if (obj2) {
23932 ecode3 = SWIG_AsVal_int(obj2, &val3);
23933 if (!SWIG_IsOK(ecode3)) {
23934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
23935 }
23936 arg3 = static_cast< int >(val3);
23937 }
23938 if (obj3) {
23939 ecode4 = SWIG_AsVal_int(obj3, &val4);
23940 if (!SWIG_IsOK(ecode4)) {
23941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
23942 }
23943 arg4 = static_cast< int >(val4);
23944 }
23945 {
23946 PyThreadState* __tstate = wxPyBeginAllowThreads();
23947 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
23948 wxPyEndAllowThreads(__tstate);
23949 if (PyErr_Occurred()) SWIG_fail;
23950 }
23951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23952 return resultobj;
23953 fail:
23954 return NULL;
23955 }
23956
23957
23958 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23959 PyObject *resultobj = 0;
23960 int arg1 ;
23961 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23962 int arg3 = (int) wxDateTime::Inv_Year ;
23963 int arg4 = (int) 0 ;
23964 int arg5 = (int) 0 ;
23965 int arg6 = (int) 0 ;
23966 int arg7 = (int) 0 ;
23967 wxDateTime *result = 0 ;
23968 int val1 ;
23969 int ecode1 = 0 ;
23970 int val2 ;
23971 int ecode2 = 0 ;
23972 int val3 ;
23973 int ecode3 = 0 ;
23974 int val4 ;
23975 int ecode4 = 0 ;
23976 int val5 ;
23977 int ecode5 = 0 ;
23978 int val6 ;
23979 int ecode6 = 0 ;
23980 int val7 ;
23981 int ecode7 = 0 ;
23982 PyObject * obj0 = 0 ;
23983 PyObject * obj1 = 0 ;
23984 PyObject * obj2 = 0 ;
23985 PyObject * obj3 = 0 ;
23986 PyObject * obj4 = 0 ;
23987 PyObject * obj5 = 0 ;
23988 PyObject * obj6 = 0 ;
23989 char * kwnames[] = {
23990 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23991 };
23992
23993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
23994 ecode1 = SWIG_AsVal_int(obj0, &val1);
23995 if (!SWIG_IsOK(ecode1)) {
23996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
23997 }
23998 arg1 = static_cast< int >(val1);
23999 if (obj1) {
24000 ecode2 = SWIG_AsVal_int(obj1, &val2);
24001 if (!SWIG_IsOK(ecode2)) {
24002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24003 }
24004 arg2 = static_cast< wxDateTime::Month >(val2);
24005 }
24006 if (obj2) {
24007 ecode3 = SWIG_AsVal_int(obj2, &val3);
24008 if (!SWIG_IsOK(ecode3)) {
24009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
24010 }
24011 arg3 = static_cast< int >(val3);
24012 }
24013 if (obj3) {
24014 ecode4 = SWIG_AsVal_int(obj3, &val4);
24015 if (!SWIG_IsOK(ecode4)) {
24016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
24017 }
24018 arg4 = static_cast< int >(val4);
24019 }
24020 if (obj4) {
24021 ecode5 = SWIG_AsVal_int(obj4, &val5);
24022 if (!SWIG_IsOK(ecode5)) {
24023 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
24024 }
24025 arg5 = static_cast< int >(val5);
24026 }
24027 if (obj5) {
24028 ecode6 = SWIG_AsVal_int(obj5, &val6);
24029 if (!SWIG_IsOK(ecode6)) {
24030 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
24031 }
24032 arg6 = static_cast< int >(val6);
24033 }
24034 if (obj6) {
24035 ecode7 = SWIG_AsVal_int(obj6, &val7);
24036 if (!SWIG_IsOK(ecode7)) {
24037 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
24038 }
24039 arg7 = static_cast< int >(val7);
24040 }
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24044 wxPyEndAllowThreads(__tstate);
24045 if (PyErr_Occurred()) SWIG_fail;
24046 }
24047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24048 return resultobj;
24049 fail:
24050 return NULL;
24051 }
24052
24053
24054 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24055 PyObject *resultobj = 0;
24056 wxDateTime *arg1 = 0 ;
24057 wxDateTime *result = 0 ;
24058 void *argp1 = 0 ;
24059 int res1 = 0 ;
24060 PyObject * obj0 = 0 ;
24061 char * kwnames[] = {
24062 (char *) "date", NULL
24063 };
24064
24065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
24066 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
24067 if (!SWIG_IsOK(res1)) {
24068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24069 }
24070 if (!argp1) {
24071 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
24072 }
24073 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24074 {
24075 PyThreadState* __tstate = wxPyBeginAllowThreads();
24076 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
24077 wxPyEndAllowThreads(__tstate);
24078 if (PyErr_Occurred()) SWIG_fail;
24079 }
24080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24081 return resultobj;
24082 fail:
24083 return NULL;
24084 }
24085
24086
24087 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24088 PyObject *resultobj = 0;
24089 wxDateTime *arg1 = (wxDateTime *) 0 ;
24090 void *argp1 = 0 ;
24091 int res1 = 0 ;
24092 PyObject *swig_obj[1] ;
24093
24094 if (!args) SWIG_fail;
24095 swig_obj[0] = args;
24096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
24097 if (!SWIG_IsOK(res1)) {
24098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24099 }
24100 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24101 {
24102 PyThreadState* __tstate = wxPyBeginAllowThreads();
24103 delete arg1;
24104
24105 wxPyEndAllowThreads(__tstate);
24106 if (PyErr_Occurred()) SWIG_fail;
24107 }
24108 resultobj = SWIG_Py_Void();
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *resultobj = 0;
24117 wxDateTime *arg1 = (wxDateTime *) 0 ;
24118 wxDateTime *result = 0 ;
24119 void *argp1 = 0 ;
24120 int res1 = 0 ;
24121 PyObject *swig_obj[1] ;
24122
24123 if (!args) SWIG_fail;
24124 swig_obj[0] = args;
24125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24126 if (!SWIG_IsOK(res1)) {
24127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
24128 }
24129 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 {
24133 wxDateTime &_result_ref = (arg1)->SetToCurrent();
24134 result = (wxDateTime *) &_result_ref;
24135 }
24136 wxPyEndAllowThreads(__tstate);
24137 if (PyErr_Occurred()) SWIG_fail;
24138 }
24139 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24140 return resultobj;
24141 fail:
24142 return NULL;
24143 }
24144
24145
24146 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24147 PyObject *resultobj = 0;
24148 wxDateTime *arg1 = (wxDateTime *) 0 ;
24149 time_t arg2 ;
24150 wxDateTime *result = 0 ;
24151 void *argp1 = 0 ;
24152 int res1 = 0 ;
24153 unsigned int val2 ;
24154 int ecode2 = 0 ;
24155 PyObject * obj0 = 0 ;
24156 PyObject * obj1 = 0 ;
24157 char * kwnames[] = {
24158 (char *) "self",(char *) "timet", NULL
24159 };
24160
24161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
24162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24163 if (!SWIG_IsOK(res1)) {
24164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24165 }
24166 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24167 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24168 if (!SWIG_IsOK(ecode2)) {
24169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
24170 }
24171 arg2 = static_cast< time_t >(val2);
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 {
24175 wxDateTime &_result_ref = (arg1)->Set(arg2);
24176 result = (wxDateTime *) &_result_ref;
24177 }
24178 wxPyEndAllowThreads(__tstate);
24179 if (PyErr_Occurred()) SWIG_fail;
24180 }
24181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24182 return resultobj;
24183 fail:
24184 return NULL;
24185 }
24186
24187
24188 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24189 PyObject *resultobj = 0;
24190 wxDateTime *arg1 = (wxDateTime *) 0 ;
24191 double arg2 ;
24192 wxDateTime *result = 0 ;
24193 void *argp1 = 0 ;
24194 int res1 = 0 ;
24195 double val2 ;
24196 int ecode2 = 0 ;
24197 PyObject * obj0 = 0 ;
24198 PyObject * obj1 = 0 ;
24199 char * kwnames[] = {
24200 (char *) "self",(char *) "jdn", NULL
24201 };
24202
24203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
24204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24205 if (!SWIG_IsOK(res1)) {
24206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24207 }
24208 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24209 ecode2 = SWIG_AsVal_double(obj1, &val2);
24210 if (!SWIG_IsOK(ecode2)) {
24211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
24212 }
24213 arg2 = static_cast< double >(val2);
24214 {
24215 PyThreadState* __tstate = wxPyBeginAllowThreads();
24216 {
24217 wxDateTime &_result_ref = (arg1)->Set(arg2);
24218 result = (wxDateTime *) &_result_ref;
24219 }
24220 wxPyEndAllowThreads(__tstate);
24221 if (PyErr_Occurred()) SWIG_fail;
24222 }
24223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj = 0;
24232 wxDateTime *arg1 = (wxDateTime *) 0 ;
24233 int arg2 ;
24234 int arg3 = (int) 0 ;
24235 int arg4 = (int) 0 ;
24236 int arg5 = (int) 0 ;
24237 wxDateTime *result = 0 ;
24238 void *argp1 = 0 ;
24239 int res1 = 0 ;
24240 int val2 ;
24241 int ecode2 = 0 ;
24242 int val3 ;
24243 int ecode3 = 0 ;
24244 int val4 ;
24245 int ecode4 = 0 ;
24246 int val5 ;
24247 int ecode5 = 0 ;
24248 PyObject * obj0 = 0 ;
24249 PyObject * obj1 = 0 ;
24250 PyObject * obj2 = 0 ;
24251 PyObject * obj3 = 0 ;
24252 PyObject * obj4 = 0 ;
24253 char * kwnames[] = {
24254 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24255 };
24256
24257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
24258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24259 if (!SWIG_IsOK(res1)) {
24260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
24261 }
24262 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24263 ecode2 = SWIG_AsVal_int(obj1, &val2);
24264 if (!SWIG_IsOK(ecode2)) {
24265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
24266 }
24267 arg2 = static_cast< int >(val2);
24268 if (obj2) {
24269 ecode3 = SWIG_AsVal_int(obj2, &val3);
24270 if (!SWIG_IsOK(ecode3)) {
24271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
24272 }
24273 arg3 = static_cast< int >(val3);
24274 }
24275 if (obj3) {
24276 ecode4 = SWIG_AsVal_int(obj3, &val4);
24277 if (!SWIG_IsOK(ecode4)) {
24278 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
24279 }
24280 arg4 = static_cast< int >(val4);
24281 }
24282 if (obj4) {
24283 ecode5 = SWIG_AsVal_int(obj4, &val5);
24284 if (!SWIG_IsOK(ecode5)) {
24285 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
24286 }
24287 arg5 = static_cast< int >(val5);
24288 }
24289 {
24290 PyThreadState* __tstate = wxPyBeginAllowThreads();
24291 {
24292 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
24293 result = (wxDateTime *) &_result_ref;
24294 }
24295 wxPyEndAllowThreads(__tstate);
24296 if (PyErr_Occurred()) SWIG_fail;
24297 }
24298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24299 return resultobj;
24300 fail:
24301 return NULL;
24302 }
24303
24304
24305 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24306 PyObject *resultobj = 0;
24307 wxDateTime *arg1 = (wxDateTime *) 0 ;
24308 int arg2 ;
24309 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24310 int arg4 = (int) wxDateTime::Inv_Year ;
24311 int arg5 = (int) 0 ;
24312 int arg6 = (int) 0 ;
24313 int arg7 = (int) 0 ;
24314 int arg8 = (int) 0 ;
24315 wxDateTime *result = 0 ;
24316 void *argp1 = 0 ;
24317 int res1 = 0 ;
24318 int val2 ;
24319 int ecode2 = 0 ;
24320 int val3 ;
24321 int ecode3 = 0 ;
24322 int val4 ;
24323 int ecode4 = 0 ;
24324 int val5 ;
24325 int ecode5 = 0 ;
24326 int val6 ;
24327 int ecode6 = 0 ;
24328 int val7 ;
24329 int ecode7 = 0 ;
24330 int val8 ;
24331 int ecode8 = 0 ;
24332 PyObject * obj0 = 0 ;
24333 PyObject * obj1 = 0 ;
24334 PyObject * obj2 = 0 ;
24335 PyObject * obj3 = 0 ;
24336 PyObject * obj4 = 0 ;
24337 PyObject * obj5 = 0 ;
24338 PyObject * obj6 = 0 ;
24339 PyObject * obj7 = 0 ;
24340 char * kwnames[] = {
24341 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
24342 };
24343
24344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
24345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24346 if (!SWIG_IsOK(res1)) {
24347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
24348 }
24349 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24350 ecode2 = SWIG_AsVal_int(obj1, &val2);
24351 if (!SWIG_IsOK(ecode2)) {
24352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
24353 }
24354 arg2 = static_cast< int >(val2);
24355 if (obj2) {
24356 ecode3 = SWIG_AsVal_int(obj2, &val3);
24357 if (!SWIG_IsOK(ecode3)) {
24358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24359 }
24360 arg3 = static_cast< wxDateTime::Month >(val3);
24361 }
24362 if (obj3) {
24363 ecode4 = SWIG_AsVal_int(obj3, &val4);
24364 if (!SWIG_IsOK(ecode4)) {
24365 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
24366 }
24367 arg4 = static_cast< int >(val4);
24368 }
24369 if (obj4) {
24370 ecode5 = SWIG_AsVal_int(obj4, &val5);
24371 if (!SWIG_IsOK(ecode5)) {
24372 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
24373 }
24374 arg5 = static_cast< int >(val5);
24375 }
24376 if (obj5) {
24377 ecode6 = SWIG_AsVal_int(obj5, &val6);
24378 if (!SWIG_IsOK(ecode6)) {
24379 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
24380 }
24381 arg6 = static_cast< int >(val6);
24382 }
24383 if (obj6) {
24384 ecode7 = SWIG_AsVal_int(obj6, &val7);
24385 if (!SWIG_IsOK(ecode7)) {
24386 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
24387 }
24388 arg7 = static_cast< int >(val7);
24389 }
24390 if (obj7) {
24391 ecode8 = SWIG_AsVal_int(obj7, &val8);
24392 if (!SWIG_IsOK(ecode8)) {
24393 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
24394 }
24395 arg8 = static_cast< int >(val8);
24396 }
24397 {
24398 PyThreadState* __tstate = wxPyBeginAllowThreads();
24399 {
24400 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24401 result = (wxDateTime *) &_result_ref;
24402 }
24403 wxPyEndAllowThreads(__tstate);
24404 if (PyErr_Occurred()) SWIG_fail;
24405 }
24406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24407 return resultobj;
24408 fail:
24409 return NULL;
24410 }
24411
24412
24413 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24414 PyObject *resultobj = 0;
24415 wxDateTime *arg1 = (wxDateTime *) 0 ;
24416 wxDateTime *result = 0 ;
24417 void *argp1 = 0 ;
24418 int res1 = 0 ;
24419 PyObject *swig_obj[1] ;
24420
24421 if (!args) SWIG_fail;
24422 swig_obj[0] = args;
24423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24424 if (!SWIG_IsOK(res1)) {
24425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
24426 }
24427 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24428 {
24429 PyThreadState* __tstate = wxPyBeginAllowThreads();
24430 {
24431 wxDateTime &_result_ref = (arg1)->ResetTime();
24432 result = (wxDateTime *) &_result_ref;
24433 }
24434 wxPyEndAllowThreads(__tstate);
24435 if (PyErr_Occurred()) SWIG_fail;
24436 }
24437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24438 return resultobj;
24439 fail:
24440 return NULL;
24441 }
24442
24443
24444 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24445 PyObject *resultobj = 0;
24446 wxDateTime *arg1 = (wxDateTime *) 0 ;
24447 int arg2 ;
24448 wxDateTime *result = 0 ;
24449 void *argp1 = 0 ;
24450 int res1 = 0 ;
24451 int val2 ;
24452 int ecode2 = 0 ;
24453 PyObject * obj0 = 0 ;
24454 PyObject * obj1 = 0 ;
24455 char * kwnames[] = {
24456 (char *) "self",(char *) "year", NULL
24457 };
24458
24459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24461 if (!SWIG_IsOK(res1)) {
24462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
24463 }
24464 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24465 ecode2 = SWIG_AsVal_int(obj1, &val2);
24466 if (!SWIG_IsOK(ecode2)) {
24467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
24468 }
24469 arg2 = static_cast< int >(val2);
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 {
24473 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
24474 result = (wxDateTime *) &_result_ref;
24475 }
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24487 PyObject *resultobj = 0;
24488 wxDateTime *arg1 = (wxDateTime *) 0 ;
24489 wxDateTime::Month arg2 ;
24490 wxDateTime *result = 0 ;
24491 void *argp1 = 0 ;
24492 int res1 = 0 ;
24493 int val2 ;
24494 int ecode2 = 0 ;
24495 PyObject * obj0 = 0 ;
24496 PyObject * obj1 = 0 ;
24497 char * kwnames[] = {
24498 (char *) "self",(char *) "month", NULL
24499 };
24500
24501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24503 if (!SWIG_IsOK(res1)) {
24504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
24505 }
24506 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24507 ecode2 = SWIG_AsVal_int(obj1, &val2);
24508 if (!SWIG_IsOK(ecode2)) {
24509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24510 }
24511 arg2 = static_cast< wxDateTime::Month >(val2);
24512 {
24513 PyThreadState* __tstate = wxPyBeginAllowThreads();
24514 {
24515 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
24516 result = (wxDateTime *) &_result_ref;
24517 }
24518 wxPyEndAllowThreads(__tstate);
24519 if (PyErr_Occurred()) SWIG_fail;
24520 }
24521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24529 PyObject *resultobj = 0;
24530 wxDateTime *arg1 = (wxDateTime *) 0 ;
24531 int arg2 ;
24532 wxDateTime *result = 0 ;
24533 void *argp1 = 0 ;
24534 int res1 = 0 ;
24535 int val2 ;
24536 int ecode2 = 0 ;
24537 PyObject * obj0 = 0 ;
24538 PyObject * obj1 = 0 ;
24539 char * kwnames[] = {
24540 (char *) "self",(char *) "day", NULL
24541 };
24542
24543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
24544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24545 if (!SWIG_IsOK(res1)) {
24546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24547 }
24548 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24549 ecode2 = SWIG_AsVal_int(obj1, &val2);
24550 if (!SWIG_IsOK(ecode2)) {
24551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
24552 }
24553 arg2 = static_cast< int >(val2);
24554 {
24555 PyThreadState* __tstate = wxPyBeginAllowThreads();
24556 {
24557 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
24558 result = (wxDateTime *) &_result_ref;
24559 }
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24564 return resultobj;
24565 fail:
24566 return NULL;
24567 }
24568
24569
24570 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24571 PyObject *resultobj = 0;
24572 wxDateTime *arg1 = (wxDateTime *) 0 ;
24573 int arg2 ;
24574 wxDateTime *result = 0 ;
24575 void *argp1 = 0 ;
24576 int res1 = 0 ;
24577 int val2 ;
24578 int ecode2 = 0 ;
24579 PyObject * obj0 = 0 ;
24580 PyObject * obj1 = 0 ;
24581 char * kwnames[] = {
24582 (char *) "self",(char *) "hour", NULL
24583 };
24584
24585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
24586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24587 if (!SWIG_IsOK(res1)) {
24588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
24589 }
24590 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24591 ecode2 = SWIG_AsVal_int(obj1, &val2);
24592 if (!SWIG_IsOK(ecode2)) {
24593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
24594 }
24595 arg2 = static_cast< int >(val2);
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 {
24599 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
24600 result = (wxDateTime *) &_result_ref;
24601 }
24602 wxPyEndAllowThreads(__tstate);
24603 if (PyErr_Occurred()) SWIG_fail;
24604 }
24605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24606 return resultobj;
24607 fail:
24608 return NULL;
24609 }
24610
24611
24612 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24613 PyObject *resultobj = 0;
24614 wxDateTime *arg1 = (wxDateTime *) 0 ;
24615 int arg2 ;
24616 wxDateTime *result = 0 ;
24617 void *argp1 = 0 ;
24618 int res1 = 0 ;
24619 int val2 ;
24620 int ecode2 = 0 ;
24621 PyObject * obj0 = 0 ;
24622 PyObject * obj1 = 0 ;
24623 char * kwnames[] = {
24624 (char *) "self",(char *) "minute", NULL
24625 };
24626
24627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
24628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24629 if (!SWIG_IsOK(res1)) {
24630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
24631 }
24632 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24633 ecode2 = SWIG_AsVal_int(obj1, &val2);
24634 if (!SWIG_IsOK(ecode2)) {
24635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
24636 }
24637 arg2 = static_cast< int >(val2);
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 {
24641 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
24642 result = (wxDateTime *) &_result_ref;
24643 }
24644 wxPyEndAllowThreads(__tstate);
24645 if (PyErr_Occurred()) SWIG_fail;
24646 }
24647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24648 return resultobj;
24649 fail:
24650 return NULL;
24651 }
24652
24653
24654 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24655 PyObject *resultobj = 0;
24656 wxDateTime *arg1 = (wxDateTime *) 0 ;
24657 int arg2 ;
24658 wxDateTime *result = 0 ;
24659 void *argp1 = 0 ;
24660 int res1 = 0 ;
24661 int val2 ;
24662 int ecode2 = 0 ;
24663 PyObject * obj0 = 0 ;
24664 PyObject * obj1 = 0 ;
24665 char * kwnames[] = {
24666 (char *) "self",(char *) "second", NULL
24667 };
24668
24669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
24670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24671 if (!SWIG_IsOK(res1)) {
24672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24673 }
24674 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24675 ecode2 = SWIG_AsVal_int(obj1, &val2);
24676 if (!SWIG_IsOK(ecode2)) {
24677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
24678 }
24679 arg2 = static_cast< int >(val2);
24680 {
24681 PyThreadState* __tstate = wxPyBeginAllowThreads();
24682 {
24683 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
24684 result = (wxDateTime *) &_result_ref;
24685 }
24686 wxPyEndAllowThreads(__tstate);
24687 if (PyErr_Occurred()) SWIG_fail;
24688 }
24689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24697 PyObject *resultobj = 0;
24698 wxDateTime *arg1 = (wxDateTime *) 0 ;
24699 int arg2 ;
24700 wxDateTime *result = 0 ;
24701 void *argp1 = 0 ;
24702 int res1 = 0 ;
24703 int val2 ;
24704 int ecode2 = 0 ;
24705 PyObject * obj0 = 0 ;
24706 PyObject * obj1 = 0 ;
24707 char * kwnames[] = {
24708 (char *) "self",(char *) "millisecond", NULL
24709 };
24710
24711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
24712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24713 if (!SWIG_IsOK(res1)) {
24714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
24715 }
24716 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24717 ecode2 = SWIG_AsVal_int(obj1, &val2);
24718 if (!SWIG_IsOK(ecode2)) {
24719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
24720 }
24721 arg2 = static_cast< int >(val2);
24722 {
24723 PyThreadState* __tstate = wxPyBeginAllowThreads();
24724 {
24725 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
24726 result = (wxDateTime *) &_result_ref;
24727 }
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24732 return resultobj;
24733 fail:
24734 return NULL;
24735 }
24736
24737
24738 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24739 PyObject *resultobj = 0;
24740 wxDateTime *arg1 = (wxDateTime *) 0 ;
24741 wxDateTime::WeekDay arg2 ;
24742 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24743 wxDateTime *result = 0 ;
24744 void *argp1 = 0 ;
24745 int res1 = 0 ;
24746 int val2 ;
24747 int ecode2 = 0 ;
24748 int val3 ;
24749 int ecode3 = 0 ;
24750 PyObject * obj0 = 0 ;
24751 PyObject * obj1 = 0 ;
24752 PyObject * obj2 = 0 ;
24753 char * kwnames[] = {
24754 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24755 };
24756
24757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24759 if (!SWIG_IsOK(res1)) {
24760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24761 }
24762 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24763 ecode2 = SWIG_AsVal_int(obj1, &val2);
24764 if (!SWIG_IsOK(ecode2)) {
24765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24766 }
24767 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24768 if (obj2) {
24769 ecode3 = SWIG_AsVal_int(obj2, &val3);
24770 if (!SWIG_IsOK(ecode3)) {
24771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24772 }
24773 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24774 }
24775 {
24776 PyThreadState* __tstate = wxPyBeginAllowThreads();
24777 {
24778 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
24779 result = (wxDateTime *) &_result_ref;
24780 }
24781 wxPyEndAllowThreads(__tstate);
24782 if (PyErr_Occurred()) SWIG_fail;
24783 }
24784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24785 return resultobj;
24786 fail:
24787 return NULL;
24788 }
24789
24790
24791 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24792 PyObject *resultobj = 0;
24793 wxDateTime *arg1 = (wxDateTime *) 0 ;
24794 wxDateTime::WeekDay arg2 ;
24795 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24796 wxDateTime result;
24797 void *argp1 = 0 ;
24798 int res1 = 0 ;
24799 int val2 ;
24800 int ecode2 = 0 ;
24801 int val3 ;
24802 int ecode3 = 0 ;
24803 PyObject * obj0 = 0 ;
24804 PyObject * obj1 = 0 ;
24805 PyObject * obj2 = 0 ;
24806 char * kwnames[] = {
24807 (char *) "self",(char *) "weekday",(char *) "flags", NULL
24808 };
24809
24810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24812 if (!SWIG_IsOK(res1)) {
24813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24814 }
24815 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24816 ecode2 = SWIG_AsVal_int(obj1, &val2);
24817 if (!SWIG_IsOK(ecode2)) {
24818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24819 }
24820 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24821 if (obj2) {
24822 ecode3 = SWIG_AsVal_int(obj2, &val3);
24823 if (!SWIG_IsOK(ecode3)) {
24824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
24825 }
24826 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
24827 }
24828 {
24829 PyThreadState* __tstate = wxPyBeginAllowThreads();
24830 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
24831 wxPyEndAllowThreads(__tstate);
24832 if (PyErr_Occurred()) SWIG_fail;
24833 }
24834 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24835 return resultobj;
24836 fail:
24837 return NULL;
24838 }
24839
24840
24841 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24842 PyObject *resultobj = 0;
24843 wxDateTime *arg1 = (wxDateTime *) 0 ;
24844 wxDateTime::WeekDay arg2 ;
24845 wxDateTime *result = 0 ;
24846 void *argp1 = 0 ;
24847 int res1 = 0 ;
24848 int val2 ;
24849 int ecode2 = 0 ;
24850 PyObject * obj0 = 0 ;
24851 PyObject * obj1 = 0 ;
24852 char * kwnames[] = {
24853 (char *) "self",(char *) "weekday", NULL
24854 };
24855
24856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24858 if (!SWIG_IsOK(res1)) {
24859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24860 }
24861 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24862 ecode2 = SWIG_AsVal_int(obj1, &val2);
24863 if (!SWIG_IsOK(ecode2)) {
24864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24865 }
24866 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24867 {
24868 PyThreadState* __tstate = wxPyBeginAllowThreads();
24869 {
24870 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
24871 result = (wxDateTime *) &_result_ref;
24872 }
24873 wxPyEndAllowThreads(__tstate);
24874 if (PyErr_Occurred()) SWIG_fail;
24875 }
24876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24877 return resultobj;
24878 fail:
24879 return NULL;
24880 }
24881
24882
24883 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24884 PyObject *resultobj = 0;
24885 wxDateTime *arg1 = (wxDateTime *) 0 ;
24886 wxDateTime::WeekDay arg2 ;
24887 wxDateTime result;
24888 void *argp1 = 0 ;
24889 int res1 = 0 ;
24890 int val2 ;
24891 int ecode2 = 0 ;
24892 PyObject * obj0 = 0 ;
24893 PyObject * obj1 = 0 ;
24894 char * kwnames[] = {
24895 (char *) "self",(char *) "weekday", NULL
24896 };
24897
24898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24902 }
24903 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24904 ecode2 = SWIG_AsVal_int(obj1, &val2);
24905 if (!SWIG_IsOK(ecode2)) {
24906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24907 }
24908 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24909 {
24910 PyThreadState* __tstate = wxPyBeginAllowThreads();
24911 result = (arg1)->GetNextWeekDay(arg2);
24912 wxPyEndAllowThreads(__tstate);
24913 if (PyErr_Occurred()) SWIG_fail;
24914 }
24915 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24916 return resultobj;
24917 fail:
24918 return NULL;
24919 }
24920
24921
24922 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24923 PyObject *resultobj = 0;
24924 wxDateTime *arg1 = (wxDateTime *) 0 ;
24925 wxDateTime::WeekDay arg2 ;
24926 wxDateTime *result = 0 ;
24927 void *argp1 = 0 ;
24928 int res1 = 0 ;
24929 int val2 ;
24930 int ecode2 = 0 ;
24931 PyObject * obj0 = 0 ;
24932 PyObject * obj1 = 0 ;
24933 char * kwnames[] = {
24934 (char *) "self",(char *) "weekday", NULL
24935 };
24936
24937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24939 if (!SWIG_IsOK(res1)) {
24940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24941 }
24942 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24943 ecode2 = SWIG_AsVal_int(obj1, &val2);
24944 if (!SWIG_IsOK(ecode2)) {
24945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24946 }
24947 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 {
24951 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
24952 result = (wxDateTime *) &_result_ref;
24953 }
24954 wxPyEndAllowThreads(__tstate);
24955 if (PyErr_Occurred()) SWIG_fail;
24956 }
24957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24958 return resultobj;
24959 fail:
24960 return NULL;
24961 }
24962
24963
24964 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24965 PyObject *resultobj = 0;
24966 wxDateTime *arg1 = (wxDateTime *) 0 ;
24967 wxDateTime::WeekDay arg2 ;
24968 wxDateTime result;
24969 void *argp1 = 0 ;
24970 int res1 = 0 ;
24971 int val2 ;
24972 int ecode2 = 0 ;
24973 PyObject * obj0 = 0 ;
24974 PyObject * obj1 = 0 ;
24975 char * kwnames[] = {
24976 (char *) "self",(char *) "weekday", NULL
24977 };
24978
24979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
24980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24981 if (!SWIG_IsOK(res1)) {
24982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24983 }
24984 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24985 ecode2 = SWIG_AsVal_int(obj1, &val2);
24986 if (!SWIG_IsOK(ecode2)) {
24987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24988 }
24989 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24990 {
24991 PyThreadState* __tstate = wxPyBeginAllowThreads();
24992 result = (arg1)->GetPrevWeekDay(arg2);
24993 wxPyEndAllowThreads(__tstate);
24994 if (PyErr_Occurred()) SWIG_fail;
24995 }
24996 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25004 PyObject *resultobj = 0;
25005 wxDateTime *arg1 = (wxDateTime *) 0 ;
25006 wxDateTime::WeekDay arg2 ;
25007 int arg3 = (int) 1 ;
25008 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25009 int arg5 = (int) wxDateTime::Inv_Year ;
25010 bool result;
25011 void *argp1 = 0 ;
25012 int res1 = 0 ;
25013 int val2 ;
25014 int ecode2 = 0 ;
25015 int val3 ;
25016 int ecode3 = 0 ;
25017 int val4 ;
25018 int ecode4 = 0 ;
25019 int val5 ;
25020 int ecode5 = 0 ;
25021 PyObject * obj0 = 0 ;
25022 PyObject * obj1 = 0 ;
25023 PyObject * obj2 = 0 ;
25024 PyObject * obj3 = 0 ;
25025 PyObject * obj4 = 0 ;
25026 char * kwnames[] = {
25027 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
25028 };
25029
25030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
25031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25032 if (!SWIG_IsOK(res1)) {
25033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25034 }
25035 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25036 ecode2 = SWIG_AsVal_int(obj1, &val2);
25037 if (!SWIG_IsOK(ecode2)) {
25038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25039 }
25040 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25041 if (obj2) {
25042 ecode3 = SWIG_AsVal_int(obj2, &val3);
25043 if (!SWIG_IsOK(ecode3)) {
25044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
25045 }
25046 arg3 = static_cast< int >(val3);
25047 }
25048 if (obj3) {
25049 ecode4 = SWIG_AsVal_int(obj3, &val4);
25050 if (!SWIG_IsOK(ecode4)) {
25051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
25052 }
25053 arg4 = static_cast< wxDateTime::Month >(val4);
25054 }
25055 if (obj4) {
25056 ecode5 = SWIG_AsVal_int(obj4, &val5);
25057 if (!SWIG_IsOK(ecode5)) {
25058 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
25059 }
25060 arg5 = static_cast< int >(val5);
25061 }
25062 {
25063 PyThreadState* __tstate = wxPyBeginAllowThreads();
25064 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25078 PyObject *resultobj = 0;
25079 wxDateTime *arg1 = (wxDateTime *) 0 ;
25080 wxDateTime::WeekDay arg2 ;
25081 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25082 int arg4 = (int) wxDateTime::Inv_Year ;
25083 bool result;
25084 void *argp1 = 0 ;
25085 int res1 = 0 ;
25086 int val2 ;
25087 int ecode2 = 0 ;
25088 int val3 ;
25089 int ecode3 = 0 ;
25090 int val4 ;
25091 int ecode4 = 0 ;
25092 PyObject * obj0 = 0 ;
25093 PyObject * obj1 = 0 ;
25094 PyObject * obj2 = 0 ;
25095 PyObject * obj3 = 0 ;
25096 char * kwnames[] = {
25097 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25098 };
25099
25100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25102 if (!SWIG_IsOK(res1)) {
25103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25104 }
25105 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25106 ecode2 = SWIG_AsVal_int(obj1, &val2);
25107 if (!SWIG_IsOK(ecode2)) {
25108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25109 }
25110 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25111 if (obj2) {
25112 ecode3 = SWIG_AsVal_int(obj2, &val3);
25113 if (!SWIG_IsOK(ecode3)) {
25114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25115 }
25116 arg3 = static_cast< wxDateTime::Month >(val3);
25117 }
25118 if (obj3) {
25119 ecode4 = SWIG_AsVal_int(obj3, &val4);
25120 if (!SWIG_IsOK(ecode4)) {
25121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25122 }
25123 arg4 = static_cast< int >(val4);
25124 }
25125 {
25126 PyThreadState* __tstate = wxPyBeginAllowThreads();
25127 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
25128 wxPyEndAllowThreads(__tstate);
25129 if (PyErr_Occurred()) SWIG_fail;
25130 }
25131 {
25132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25133 }
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25141 PyObject *resultobj = 0;
25142 wxDateTime *arg1 = (wxDateTime *) 0 ;
25143 wxDateTime::WeekDay arg2 ;
25144 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25145 int arg4 = (int) wxDateTime::Inv_Year ;
25146 wxDateTime result;
25147 void *argp1 = 0 ;
25148 int res1 = 0 ;
25149 int val2 ;
25150 int ecode2 = 0 ;
25151 int val3 ;
25152 int ecode3 = 0 ;
25153 int val4 ;
25154 int ecode4 = 0 ;
25155 PyObject * obj0 = 0 ;
25156 PyObject * obj1 = 0 ;
25157 PyObject * obj2 = 0 ;
25158 PyObject * obj3 = 0 ;
25159 char * kwnames[] = {
25160 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
25161 };
25162
25163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25165 if (!SWIG_IsOK(res1)) {
25166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25167 }
25168 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25169 ecode2 = SWIG_AsVal_int(obj1, &val2);
25170 if (!SWIG_IsOK(ecode2)) {
25171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
25172 }
25173 arg2 = static_cast< wxDateTime::WeekDay >(val2);
25174 if (obj2) {
25175 ecode3 = SWIG_AsVal_int(obj2, &val3);
25176 if (!SWIG_IsOK(ecode3)) {
25177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
25178 }
25179 arg3 = static_cast< wxDateTime::Month >(val3);
25180 }
25181 if (obj3) {
25182 ecode4 = SWIG_AsVal_int(obj3, &val4);
25183 if (!SWIG_IsOK(ecode4)) {
25184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
25185 }
25186 arg4 = static_cast< int >(val4);
25187 }
25188 {
25189 PyThreadState* __tstate = wxPyBeginAllowThreads();
25190 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
25191 wxPyEndAllowThreads(__tstate);
25192 if (PyErr_Occurred()) SWIG_fail;
25193 }
25194 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25195 return resultobj;
25196 fail:
25197 return NULL;
25198 }
25199
25200
25201 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25202 PyObject *resultobj = 0;
25203 wxDateTime *arg1 = (wxDateTime *) 0 ;
25204 int arg2 ;
25205 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25206 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25207 bool result;
25208 void *argp1 = 0 ;
25209 int res1 = 0 ;
25210 int val2 ;
25211 int ecode2 = 0 ;
25212 int val3 ;
25213 int ecode3 = 0 ;
25214 int val4 ;
25215 int ecode4 = 0 ;
25216 PyObject * obj0 = 0 ;
25217 PyObject * obj1 = 0 ;
25218 PyObject * obj2 = 0 ;
25219 PyObject * obj3 = 0 ;
25220 char * kwnames[] = {
25221 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25222 };
25223
25224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25226 if (!SWIG_IsOK(res1)) {
25227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25228 }
25229 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25230 ecode2 = SWIG_AsVal_int(obj1, &val2);
25231 if (!SWIG_IsOK(ecode2)) {
25232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
25233 }
25234 arg2 = static_cast< int >(val2);
25235 if (obj2) {
25236 ecode3 = SWIG_AsVal_int(obj2, &val3);
25237 if (!SWIG_IsOK(ecode3)) {
25238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25239 }
25240 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25241 }
25242 if (obj3) {
25243 ecode4 = SWIG_AsVal_int(obj3, &val4);
25244 if (!SWIG_IsOK(ecode4)) {
25245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25246 }
25247 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25248 }
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
25252 wxPyEndAllowThreads(__tstate);
25253 if (PyErr_Occurred()) SWIG_fail;
25254 }
25255 {
25256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25257 }
25258 return resultobj;
25259 fail:
25260 return NULL;
25261 }
25262
25263
25264 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25265 PyObject *resultobj = 0;
25266 wxDateTime *arg1 = (wxDateTime *) 0 ;
25267 int arg2 ;
25268 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25269 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25270 wxDateTime result;
25271 void *argp1 = 0 ;
25272 int res1 = 0 ;
25273 int val2 ;
25274 int ecode2 = 0 ;
25275 int val3 ;
25276 int ecode3 = 0 ;
25277 int val4 ;
25278 int ecode4 = 0 ;
25279 PyObject * obj0 = 0 ;
25280 PyObject * obj1 = 0 ;
25281 PyObject * obj2 = 0 ;
25282 PyObject * obj3 = 0 ;
25283 char * kwnames[] = {
25284 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
25285 };
25286
25287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25289 if (!SWIG_IsOK(res1)) {
25290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
25291 }
25292 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25293 ecode2 = SWIG_AsVal_int(obj1, &val2);
25294 if (!SWIG_IsOK(ecode2)) {
25295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
25296 }
25297 arg2 = static_cast< int >(val2);
25298 if (obj2) {
25299 ecode3 = SWIG_AsVal_int(obj2, &val3);
25300 if (!SWIG_IsOK(ecode3)) {
25301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25302 }
25303 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25304 }
25305 if (obj3) {
25306 ecode4 = SWIG_AsVal_int(obj3, &val4);
25307 if (!SWIG_IsOK(ecode4)) {
25308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
25309 }
25310 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
25311 }
25312 {
25313 PyThreadState* __tstate = wxPyBeginAllowThreads();
25314 result = (arg1)->GetWeek(arg2,arg3,arg4);
25315 wxPyEndAllowThreads(__tstate);
25316 if (PyErr_Occurred()) SWIG_fail;
25317 }
25318 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25319 return resultobj;
25320 fail:
25321 return NULL;
25322 }
25323
25324
25325 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25326 PyObject *resultobj = 0;
25327 int arg1 ;
25328 int arg2 ;
25329 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
25330 wxDateTime result;
25331 int val1 ;
25332 int ecode1 = 0 ;
25333 int val2 ;
25334 int ecode2 = 0 ;
25335 int val3 ;
25336 int ecode3 = 0 ;
25337 PyObject * obj0 = 0 ;
25338 PyObject * obj1 = 0 ;
25339 PyObject * obj2 = 0 ;
25340 char * kwnames[] = {
25341 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
25342 };
25343
25344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25345 ecode1 = SWIG_AsVal_int(obj0, &val1);
25346 if (!SWIG_IsOK(ecode1)) {
25347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
25348 }
25349 arg1 = static_cast< int >(val1);
25350 ecode2 = SWIG_AsVal_int(obj1, &val2);
25351 if (!SWIG_IsOK(ecode2)) {
25352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
25353 }
25354 arg2 = static_cast< int >(val2);
25355 if (obj2) {
25356 ecode3 = SWIG_AsVal_int(obj2, &val3);
25357 if (!SWIG_IsOK(ecode3)) {
25358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
25359 }
25360 arg3 = static_cast< wxDateTime::WeekDay >(val3);
25361 }
25362 {
25363 PyThreadState* __tstate = wxPyBeginAllowThreads();
25364 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
25365 wxPyEndAllowThreads(__tstate);
25366 if (PyErr_Occurred()) SWIG_fail;
25367 }
25368 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25369 return resultobj;
25370 fail:
25371 return NULL;
25372 }
25373
25374
25375 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25376 PyObject *resultobj = 0;
25377 wxDateTime *arg1 = (wxDateTime *) 0 ;
25378 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25379 int arg3 = (int) wxDateTime::Inv_Year ;
25380 wxDateTime *result = 0 ;
25381 void *argp1 = 0 ;
25382 int res1 = 0 ;
25383 int val2 ;
25384 int ecode2 = 0 ;
25385 int val3 ;
25386 int ecode3 = 0 ;
25387 PyObject * obj0 = 0 ;
25388 PyObject * obj1 = 0 ;
25389 PyObject * obj2 = 0 ;
25390 char * kwnames[] = {
25391 (char *) "self",(char *) "month",(char *) "year", NULL
25392 };
25393
25394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25396 if (!SWIG_IsOK(res1)) {
25397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25398 }
25399 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25400 if (obj1) {
25401 ecode2 = SWIG_AsVal_int(obj1, &val2);
25402 if (!SWIG_IsOK(ecode2)) {
25403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25404 }
25405 arg2 = static_cast< wxDateTime::Month >(val2);
25406 }
25407 if (obj2) {
25408 ecode3 = SWIG_AsVal_int(obj2, &val3);
25409 if (!SWIG_IsOK(ecode3)) {
25410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25411 }
25412 arg3 = static_cast< int >(val3);
25413 }
25414 {
25415 PyThreadState* __tstate = wxPyBeginAllowThreads();
25416 {
25417 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
25418 result = (wxDateTime *) &_result_ref;
25419 }
25420 wxPyEndAllowThreads(__tstate);
25421 if (PyErr_Occurred()) SWIG_fail;
25422 }
25423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25431 PyObject *resultobj = 0;
25432 wxDateTime *arg1 = (wxDateTime *) 0 ;
25433 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
25434 int arg3 = (int) wxDateTime::Inv_Year ;
25435 wxDateTime result;
25436 void *argp1 = 0 ;
25437 int res1 = 0 ;
25438 int val2 ;
25439 int ecode2 = 0 ;
25440 int val3 ;
25441 int ecode3 = 0 ;
25442 PyObject * obj0 = 0 ;
25443 PyObject * obj1 = 0 ;
25444 PyObject * obj2 = 0 ;
25445 char * kwnames[] = {
25446 (char *) "self",(char *) "month",(char *) "year", NULL
25447 };
25448
25449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25451 if (!SWIG_IsOK(res1)) {
25452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25453 }
25454 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25455 if (obj1) {
25456 ecode2 = SWIG_AsVal_int(obj1, &val2);
25457 if (!SWIG_IsOK(ecode2)) {
25458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
25459 }
25460 arg2 = static_cast< wxDateTime::Month >(val2);
25461 }
25462 if (obj2) {
25463 ecode3 = SWIG_AsVal_int(obj2, &val3);
25464 if (!SWIG_IsOK(ecode3)) {
25465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
25466 }
25467 arg3 = static_cast< int >(val3);
25468 }
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 result = (arg1)->GetLastMonthDay(arg2,arg3);
25472 wxPyEndAllowThreads(__tstate);
25473 if (PyErr_Occurred()) SWIG_fail;
25474 }
25475 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25483 PyObject *resultobj = 0;
25484 wxDateTime *arg1 = (wxDateTime *) 0 ;
25485 int arg2 ;
25486 wxDateTime *result = 0 ;
25487 void *argp1 = 0 ;
25488 int res1 = 0 ;
25489 int val2 ;
25490 int ecode2 = 0 ;
25491 PyObject * obj0 = 0 ;
25492 PyObject * obj1 = 0 ;
25493 char * kwnames[] = {
25494 (char *) "self",(char *) "yday", NULL
25495 };
25496
25497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25499 if (!SWIG_IsOK(res1)) {
25500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25501 }
25502 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25503 ecode2 = SWIG_AsVal_int(obj1, &val2);
25504 if (!SWIG_IsOK(ecode2)) {
25505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
25506 }
25507 arg2 = static_cast< int >(val2);
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 {
25511 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
25512 result = (wxDateTime *) &_result_ref;
25513 }
25514 wxPyEndAllowThreads(__tstate);
25515 if (PyErr_Occurred()) SWIG_fail;
25516 }
25517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj = 0;
25526 wxDateTime *arg1 = (wxDateTime *) 0 ;
25527 int arg2 ;
25528 wxDateTime result;
25529 void *argp1 = 0 ;
25530 int res1 = 0 ;
25531 int val2 ;
25532 int ecode2 = 0 ;
25533 PyObject * obj0 = 0 ;
25534 PyObject * obj1 = 0 ;
25535 char * kwnames[] = {
25536 (char *) "self",(char *) "yday", NULL
25537 };
25538
25539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
25540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25541 if (!SWIG_IsOK(res1)) {
25542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
25543 }
25544 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25545 ecode2 = SWIG_AsVal_int(obj1, &val2);
25546 if (!SWIG_IsOK(ecode2)) {
25547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
25548 }
25549 arg2 = static_cast< int >(val2);
25550 {
25551 PyThreadState* __tstate = wxPyBeginAllowThreads();
25552 result = (arg1)->GetYearDay(arg2);
25553 wxPyEndAllowThreads(__tstate);
25554 if (PyErr_Occurred()) SWIG_fail;
25555 }
25556 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25557 return resultobj;
25558 fail:
25559 return NULL;
25560 }
25561
25562
25563 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25564 PyObject *resultobj = 0;
25565 wxDateTime *arg1 = (wxDateTime *) 0 ;
25566 double result;
25567 void *argp1 = 0 ;
25568 int res1 = 0 ;
25569 PyObject *swig_obj[1] ;
25570
25571 if (!args) SWIG_fail;
25572 swig_obj[0] = args;
25573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25574 if (!SWIG_IsOK(res1)) {
25575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
25576 }
25577 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25578 {
25579 PyThreadState* __tstate = wxPyBeginAllowThreads();
25580 result = (double)(arg1)->GetJulianDayNumber();
25581 wxPyEndAllowThreads(__tstate);
25582 if (PyErr_Occurred()) SWIG_fail;
25583 }
25584 resultobj = SWIG_From_double(static_cast< double >(result));
25585 return resultobj;
25586 fail:
25587 return NULL;
25588 }
25589
25590
25591 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25592 PyObject *resultobj = 0;
25593 wxDateTime *arg1 = (wxDateTime *) 0 ;
25594 double result;
25595 void *argp1 = 0 ;
25596 int res1 = 0 ;
25597 PyObject *swig_obj[1] ;
25598
25599 if (!args) SWIG_fail;
25600 swig_obj[0] = args;
25601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25602 if (!SWIG_IsOK(res1)) {
25603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
25604 }
25605 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25606 {
25607 PyThreadState* __tstate = wxPyBeginAllowThreads();
25608 result = (double)(arg1)->GetJDN();
25609 wxPyEndAllowThreads(__tstate);
25610 if (PyErr_Occurred()) SWIG_fail;
25611 }
25612 resultobj = SWIG_From_double(static_cast< double >(result));
25613 return resultobj;
25614 fail:
25615 return NULL;
25616 }
25617
25618
25619 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25620 PyObject *resultobj = 0;
25621 wxDateTime *arg1 = (wxDateTime *) 0 ;
25622 double result;
25623 void *argp1 = 0 ;
25624 int res1 = 0 ;
25625 PyObject *swig_obj[1] ;
25626
25627 if (!args) SWIG_fail;
25628 swig_obj[0] = args;
25629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25630 if (!SWIG_IsOK(res1)) {
25631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25632 }
25633 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_From_double(static_cast< double >(result));
25641 return resultobj;
25642 fail:
25643 return NULL;
25644 }
25645
25646
25647 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25648 PyObject *resultobj = 0;
25649 wxDateTime *arg1 = (wxDateTime *) 0 ;
25650 double result;
25651 void *argp1 = 0 ;
25652 int res1 = 0 ;
25653 PyObject *swig_obj[1] ;
25654
25655 if (!args) SWIG_fail;
25656 swig_obj[0] = args;
25657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25658 if (!SWIG_IsOK(res1)) {
25659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
25660 }
25661 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 result = (double)(arg1)->GetMJD();
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 resultobj = SWIG_From_double(static_cast< double >(result));
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25676 PyObject *resultobj = 0;
25677 wxDateTime *arg1 = (wxDateTime *) 0 ;
25678 double result;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 PyObject *swig_obj[1] ;
25682
25683 if (!args) SWIG_fail;
25684 swig_obj[0] = args;
25685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25686 if (!SWIG_IsOK(res1)) {
25687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
25688 }
25689 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25690 {
25691 PyThreadState* __tstate = wxPyBeginAllowThreads();
25692 result = (double)(arg1)->GetRataDie();
25693 wxPyEndAllowThreads(__tstate);
25694 if (PyErr_Occurred()) SWIG_fail;
25695 }
25696 resultobj = SWIG_From_double(static_cast< double >(result));
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25704 PyObject *resultobj = 0;
25705 wxDateTime *arg1 = (wxDateTime *) 0 ;
25706 wxDateTime::TimeZone *arg2 = 0 ;
25707 bool arg3 = (bool) false ;
25708 wxDateTime result;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 bool temp2 = false ;
25712 bool val3 ;
25713 int ecode3 = 0 ;
25714 PyObject * obj0 = 0 ;
25715 PyObject * obj1 = 0 ;
25716 PyObject * obj2 = 0 ;
25717 char * kwnames[] = {
25718 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25719 };
25720
25721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25723 if (!SWIG_IsOK(res1)) {
25724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25725 }
25726 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25727 {
25728 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25729 temp2 = true;
25730 }
25731 if (obj2) {
25732 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25733 if (!SWIG_IsOK(ecode3)) {
25734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
25735 }
25736 arg3 = static_cast< bool >(val3);
25737 }
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25745 {
25746 if (temp2) delete arg2;
25747 }
25748 return resultobj;
25749 fail:
25750 {
25751 if (temp2) delete arg2;
25752 }
25753 return NULL;
25754 }
25755
25756
25757 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25758 PyObject *resultobj = 0;
25759 wxDateTime *arg1 = (wxDateTime *) 0 ;
25760 wxDateTime::TimeZone *arg2 = 0 ;
25761 bool arg3 = (bool) false ;
25762 wxDateTime *result = 0 ;
25763 void *argp1 = 0 ;
25764 int res1 = 0 ;
25765 bool temp2 = false ;
25766 bool val3 ;
25767 int ecode3 = 0 ;
25768 PyObject * obj0 = 0 ;
25769 PyObject * obj1 = 0 ;
25770 PyObject * obj2 = 0 ;
25771 char * kwnames[] = {
25772 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25773 };
25774
25775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25777 if (!SWIG_IsOK(res1)) {
25778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25779 }
25780 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25781 {
25782 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25783 temp2 = true;
25784 }
25785 if (obj2) {
25786 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25787 if (!SWIG_IsOK(ecode3)) {
25788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
25789 }
25790 arg3 = static_cast< bool >(val3);
25791 }
25792 {
25793 PyThreadState* __tstate = wxPyBeginAllowThreads();
25794 {
25795 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25796 result = (wxDateTime *) &_result_ref;
25797 }
25798 wxPyEndAllowThreads(__tstate);
25799 if (PyErr_Occurred()) SWIG_fail;
25800 }
25801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25802 {
25803 if (temp2) delete arg2;
25804 }
25805 return resultobj;
25806 fail:
25807 {
25808 if (temp2) delete arg2;
25809 }
25810 return NULL;
25811 }
25812
25813
25814 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25815 PyObject *resultobj = 0;
25816 wxDateTime *arg1 = (wxDateTime *) 0 ;
25817 wxDateTime::TimeZone *arg2 = 0 ;
25818 bool arg3 = (bool) false ;
25819 wxDateTime result;
25820 void *argp1 = 0 ;
25821 int res1 = 0 ;
25822 bool temp2 = false ;
25823 bool val3 ;
25824 int ecode3 = 0 ;
25825 PyObject * obj0 = 0 ;
25826 PyObject * obj1 = 0 ;
25827 PyObject * obj2 = 0 ;
25828 char * kwnames[] = {
25829 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25830 };
25831
25832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25834 if (!SWIG_IsOK(res1)) {
25835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25836 }
25837 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25838 {
25839 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25840 temp2 = true;
25841 }
25842 if (obj2) {
25843 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25844 if (!SWIG_IsOK(ecode3)) {
25845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
25846 }
25847 arg3 = static_cast< bool >(val3);
25848 }
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25852 wxPyEndAllowThreads(__tstate);
25853 if (PyErr_Occurred()) SWIG_fail;
25854 }
25855 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25856 {
25857 if (temp2) delete arg2;
25858 }
25859 return resultobj;
25860 fail:
25861 {
25862 if (temp2) delete arg2;
25863 }
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25869 PyObject *resultobj = 0;
25870 wxDateTime *arg1 = (wxDateTime *) 0 ;
25871 wxDateTime::TimeZone *arg2 = 0 ;
25872 bool arg3 = (bool) false ;
25873 wxDateTime *result = 0 ;
25874 void *argp1 = 0 ;
25875 int res1 = 0 ;
25876 bool temp2 = false ;
25877 bool val3 ;
25878 int ecode3 = 0 ;
25879 PyObject * obj0 = 0 ;
25880 PyObject * obj1 = 0 ;
25881 PyObject * obj2 = 0 ;
25882 char * kwnames[] = {
25883 (char *) "self",(char *) "tz",(char *) "noDST", NULL
25884 };
25885
25886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25888 if (!SWIG_IsOK(res1)) {
25889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
25890 }
25891 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25892 {
25893 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25894 temp2 = true;
25895 }
25896 if (obj2) {
25897 ecode3 = SWIG_AsVal_bool(obj2, &val3);
25898 if (!SWIG_IsOK(ecode3)) {
25899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
25900 }
25901 arg3 = static_cast< bool >(val3);
25902 }
25903 {
25904 PyThreadState* __tstate = wxPyBeginAllowThreads();
25905 {
25906 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
25907 result = (wxDateTime *) &_result_ref;
25908 }
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25913 {
25914 if (temp2) delete arg2;
25915 }
25916 return resultobj;
25917 fail:
25918 {
25919 if (temp2) delete arg2;
25920 }
25921 return NULL;
25922 }
25923
25924
25925 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25926 PyObject *resultobj = 0;
25927 wxDateTime *arg1 = (wxDateTime *) 0 ;
25928 bool arg2 = (bool) false ;
25929 wxDateTime result;
25930 void *argp1 = 0 ;
25931 int res1 = 0 ;
25932 bool val2 ;
25933 int ecode2 = 0 ;
25934 PyObject * obj0 = 0 ;
25935 PyObject * obj1 = 0 ;
25936 char * kwnames[] = {
25937 (char *) "self",(char *) "noDST", NULL
25938 };
25939
25940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25942 if (!SWIG_IsOK(res1)) {
25943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25944 }
25945 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25946 if (obj1) {
25947 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25948 if (!SWIG_IsOK(ecode2)) {
25949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
25950 }
25951 arg2 = static_cast< bool >(val2);
25952 }
25953 {
25954 PyThreadState* __tstate = wxPyBeginAllowThreads();
25955 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
25956 wxPyEndAllowThreads(__tstate);
25957 if (PyErr_Occurred()) SWIG_fail;
25958 }
25959 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25967 PyObject *resultobj = 0;
25968 wxDateTime *arg1 = (wxDateTime *) 0 ;
25969 bool arg2 = (bool) false ;
25970 wxDateTime *result = 0 ;
25971 void *argp1 = 0 ;
25972 int res1 = 0 ;
25973 bool val2 ;
25974 int ecode2 = 0 ;
25975 PyObject * obj0 = 0 ;
25976 PyObject * obj1 = 0 ;
25977 char * kwnames[] = {
25978 (char *) "self",(char *) "noDST", NULL
25979 };
25980
25981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25983 if (!SWIG_IsOK(res1)) {
25984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25985 }
25986 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25987 if (obj1) {
25988 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25989 if (!SWIG_IsOK(ecode2)) {
25990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
25991 }
25992 arg2 = static_cast< bool >(val2);
25993 }
25994 {
25995 PyThreadState* __tstate = wxPyBeginAllowThreads();
25996 {
25997 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
25998 result = (wxDateTime *) &_result_ref;
25999 }
26000 wxPyEndAllowThreads(__tstate);
26001 if (PyErr_Occurred()) SWIG_fail;
26002 }
26003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj = 0;
26012 wxDateTime *arg1 = (wxDateTime *) 0 ;
26013 bool arg2 = (bool) false ;
26014 wxDateTime result;
26015 void *argp1 = 0 ;
26016 int res1 = 0 ;
26017 bool val2 ;
26018 int ecode2 = 0 ;
26019 PyObject * obj0 = 0 ;
26020 PyObject * obj1 = 0 ;
26021 char * kwnames[] = {
26022 (char *) "self",(char *) "noDST", NULL
26023 };
26024
26025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26027 if (!SWIG_IsOK(res1)) {
26028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26029 }
26030 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26031 if (obj1) {
26032 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26033 if (!SWIG_IsOK(ecode2)) {
26034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
26035 }
26036 arg2 = static_cast< bool >(val2);
26037 }
26038 {
26039 PyThreadState* __tstate = wxPyBeginAllowThreads();
26040 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
26041 wxPyEndAllowThreads(__tstate);
26042 if (PyErr_Occurred()) SWIG_fail;
26043 }
26044 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26045 return resultobj;
26046 fail:
26047 return NULL;
26048 }
26049
26050
26051 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26052 PyObject *resultobj = 0;
26053 wxDateTime *arg1 = (wxDateTime *) 0 ;
26054 bool arg2 = (bool) false ;
26055 wxDateTime *result = 0 ;
26056 void *argp1 = 0 ;
26057 int res1 = 0 ;
26058 bool val2 ;
26059 int ecode2 = 0 ;
26060 PyObject * obj0 = 0 ;
26061 PyObject * obj1 = 0 ;
26062 char * kwnames[] = {
26063 (char *) "self",(char *) "noDST", NULL
26064 };
26065
26066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
26067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26068 if (!SWIG_IsOK(res1)) {
26069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
26070 }
26071 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26072 if (obj1) {
26073 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26074 if (!SWIG_IsOK(ecode2)) {
26075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
26076 }
26077 arg2 = static_cast< bool >(val2);
26078 }
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 {
26082 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
26083 result = (wxDateTime *) &_result_ref;
26084 }
26085 wxPyEndAllowThreads(__tstate);
26086 if (PyErr_Occurred()) SWIG_fail;
26087 }
26088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26089 return resultobj;
26090 fail:
26091 return NULL;
26092 }
26093
26094
26095 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26096 PyObject *resultobj = 0;
26097 wxDateTime *arg1 = (wxDateTime *) 0 ;
26098 bool arg2 = (bool) false ;
26099 wxDateTime result;
26100 void *argp1 = 0 ;
26101 int res1 = 0 ;
26102 bool val2 ;
26103 int ecode2 = 0 ;
26104 PyObject * obj0 = 0 ;
26105 PyObject * obj1 = 0 ;
26106 char * kwnames[] = {
26107 (char *) "self",(char *) "noDST", NULL
26108 };
26109
26110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26112 if (!SWIG_IsOK(res1)) {
26113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26114 }
26115 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26116 if (obj1) {
26117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26118 if (!SWIG_IsOK(ecode2)) {
26119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
26120 }
26121 arg2 = static_cast< bool >(val2);
26122 }
26123 {
26124 PyThreadState* __tstate = wxPyBeginAllowThreads();
26125 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj = 0;
26138 wxDateTime *arg1 = (wxDateTime *) 0 ;
26139 bool arg2 = (bool) false ;
26140 wxDateTime *result = 0 ;
26141 void *argp1 = 0 ;
26142 int res1 = 0 ;
26143 bool val2 ;
26144 int ecode2 = 0 ;
26145 PyObject * obj0 = 0 ;
26146 PyObject * obj1 = 0 ;
26147 char * kwnames[] = {
26148 (char *) "self",(char *) "noDST", NULL
26149 };
26150
26151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
26152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26153 if (!SWIG_IsOK(res1)) {
26154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
26155 }
26156 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26157 if (obj1) {
26158 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26159 if (!SWIG_IsOK(ecode2)) {
26160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
26161 }
26162 arg2 = static_cast< bool >(val2);
26163 }
26164 {
26165 PyThreadState* __tstate = wxPyBeginAllowThreads();
26166 {
26167 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
26168 result = (wxDateTime *) &_result_ref;
26169 }
26170 wxPyEndAllowThreads(__tstate);
26171 if (PyErr_Occurred()) SWIG_fail;
26172 }
26173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26174 return resultobj;
26175 fail:
26176 return NULL;
26177 }
26178
26179
26180 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26181 PyObject *resultobj = 0;
26182 wxDateTime *arg1 = (wxDateTime *) 0 ;
26183 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26184 int result;
26185 void *argp1 = 0 ;
26186 int res1 = 0 ;
26187 int val2 ;
26188 int ecode2 = 0 ;
26189 PyObject * obj0 = 0 ;
26190 PyObject * obj1 = 0 ;
26191 char * kwnames[] = {
26192 (char *) "self",(char *) "country", NULL
26193 };
26194
26195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
26196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26197 if (!SWIG_IsOK(res1)) {
26198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
26199 }
26200 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26201 if (obj1) {
26202 ecode2 = SWIG_AsVal_int(obj1, &val2);
26203 if (!SWIG_IsOK(ecode2)) {
26204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26205 }
26206 arg2 = static_cast< wxDateTime::Country >(val2);
26207 }
26208 {
26209 PyThreadState* __tstate = wxPyBeginAllowThreads();
26210 result = (int)(arg1)->IsDST(arg2);
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 resultobj = SWIG_From_int(static_cast< int >(result));
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 PyObject *resultobj = 0;
26223 wxDateTime *arg1 = (wxDateTime *) 0 ;
26224 bool result;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 PyObject *swig_obj[1] ;
26228
26229 if (!args) SWIG_fail;
26230 swig_obj[0] = args;
26231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26232 if (!SWIG_IsOK(res1)) {
26233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26234 }
26235 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26236 {
26237 PyThreadState* __tstate = wxPyBeginAllowThreads();
26238 result = (bool)((wxDateTime const *)arg1)->IsValid();
26239 wxPyEndAllowThreads(__tstate);
26240 if (PyErr_Occurred()) SWIG_fail;
26241 }
26242 {
26243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26244 }
26245 return resultobj;
26246 fail:
26247 return NULL;
26248 }
26249
26250
26251 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26252 PyObject *resultobj = 0;
26253 wxDateTime *arg1 = (wxDateTime *) 0 ;
26254 time_t result;
26255 void *argp1 = 0 ;
26256 int res1 = 0 ;
26257 PyObject *swig_obj[1] ;
26258
26259 if (!args) SWIG_fail;
26260 swig_obj[0] = args;
26261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26262 if (!SWIG_IsOK(res1)) {
26263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26264 }
26265 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26266 {
26267 PyThreadState* __tstate = wxPyBeginAllowThreads();
26268 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
26269 wxPyEndAllowThreads(__tstate);
26270 if (PyErr_Occurred()) SWIG_fail;
26271 }
26272 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26273 return resultobj;
26274 fail:
26275 return NULL;
26276 }
26277
26278
26279 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26280 PyObject *resultobj = 0;
26281 wxDateTime *arg1 = (wxDateTime *) 0 ;
26282 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26283 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26284 int result;
26285 void *argp1 = 0 ;
26286 int res1 = 0 ;
26287 bool temp2 = false ;
26288 PyObject * obj0 = 0 ;
26289 PyObject * obj1 = 0 ;
26290 char * kwnames[] = {
26291 (char *) "self",(char *) "tz", NULL
26292 };
26293
26294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
26295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26296 if (!SWIG_IsOK(res1)) {
26297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26298 }
26299 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26300 if (obj1) {
26301 {
26302 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26303 temp2 = true;
26304 }
26305 }
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 resultobj = SWIG_From_int(static_cast< int >(result));
26313 {
26314 if (temp2) delete arg2;
26315 }
26316 return resultobj;
26317 fail:
26318 {
26319 if (temp2) delete arg2;
26320 }
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26326 PyObject *resultobj = 0;
26327 wxDateTime *arg1 = (wxDateTime *) 0 ;
26328 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26329 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26330 wxDateTime::Month result;
26331 void *argp1 = 0 ;
26332 int res1 = 0 ;
26333 bool temp2 = false ;
26334 PyObject * obj0 = 0 ;
26335 PyObject * obj1 = 0 ;
26336 char * kwnames[] = {
26337 (char *) "self",(char *) "tz", NULL
26338 };
26339
26340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
26341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26342 if (!SWIG_IsOK(res1)) {
26343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26344 }
26345 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26346 if (obj1) {
26347 {
26348 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26349 temp2 = true;
26350 }
26351 }
26352 {
26353 PyThreadState* __tstate = wxPyBeginAllowThreads();
26354 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
26355 wxPyEndAllowThreads(__tstate);
26356 if (PyErr_Occurred()) SWIG_fail;
26357 }
26358 resultobj = SWIG_From_int(static_cast< int >(result));
26359 {
26360 if (temp2) delete arg2;
26361 }
26362 return resultobj;
26363 fail:
26364 {
26365 if (temp2) delete arg2;
26366 }
26367 return NULL;
26368 }
26369
26370
26371 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26372 PyObject *resultobj = 0;
26373 wxDateTime *arg1 = (wxDateTime *) 0 ;
26374 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26375 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26376 int result;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 bool temp2 = false ;
26380 PyObject * obj0 = 0 ;
26381 PyObject * obj1 = 0 ;
26382 char * kwnames[] = {
26383 (char *) "self",(char *) "tz", NULL
26384 };
26385
26386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
26387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26388 if (!SWIG_IsOK(res1)) {
26389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26390 }
26391 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26392 if (obj1) {
26393 {
26394 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26395 temp2 = true;
26396 }
26397 }
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
26401 wxPyEndAllowThreads(__tstate);
26402 if (PyErr_Occurred()) SWIG_fail;
26403 }
26404 resultobj = SWIG_From_int(static_cast< int >(result));
26405 {
26406 if (temp2) delete arg2;
26407 }
26408 return resultobj;
26409 fail:
26410 {
26411 if (temp2) delete arg2;
26412 }
26413 return NULL;
26414 }
26415
26416
26417 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26418 PyObject *resultobj = 0;
26419 wxDateTime *arg1 = (wxDateTime *) 0 ;
26420 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26421 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26422 wxDateTime::WeekDay result;
26423 void *argp1 = 0 ;
26424 int res1 = 0 ;
26425 bool temp2 = false ;
26426 PyObject * obj0 = 0 ;
26427 PyObject * obj1 = 0 ;
26428 char * kwnames[] = {
26429 (char *) "self",(char *) "tz", NULL
26430 };
26431
26432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
26433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26434 if (!SWIG_IsOK(res1)) {
26435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26436 }
26437 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26438 if (obj1) {
26439 {
26440 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26441 temp2 = true;
26442 }
26443 }
26444 {
26445 PyThreadState* __tstate = wxPyBeginAllowThreads();
26446 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 resultobj = SWIG_From_int(static_cast< int >(result));
26451 {
26452 if (temp2) delete arg2;
26453 }
26454 return resultobj;
26455 fail:
26456 {
26457 if (temp2) delete arg2;
26458 }
26459 return NULL;
26460 }
26461
26462
26463 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26464 PyObject *resultobj = 0;
26465 wxDateTime *arg1 = (wxDateTime *) 0 ;
26466 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26467 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26468 int result;
26469 void *argp1 = 0 ;
26470 int res1 = 0 ;
26471 bool temp2 = false ;
26472 PyObject * obj0 = 0 ;
26473 PyObject * obj1 = 0 ;
26474 char * kwnames[] = {
26475 (char *) "self",(char *) "tz", NULL
26476 };
26477
26478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
26479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26480 if (!SWIG_IsOK(res1)) {
26481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26482 }
26483 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26484 if (obj1) {
26485 {
26486 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26487 temp2 = true;
26488 }
26489 }
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
26493 wxPyEndAllowThreads(__tstate);
26494 if (PyErr_Occurred()) SWIG_fail;
26495 }
26496 resultobj = SWIG_From_int(static_cast< int >(result));
26497 {
26498 if (temp2) delete arg2;
26499 }
26500 return resultobj;
26501 fail:
26502 {
26503 if (temp2) delete arg2;
26504 }
26505 return NULL;
26506 }
26507
26508
26509 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26510 PyObject *resultobj = 0;
26511 wxDateTime *arg1 = (wxDateTime *) 0 ;
26512 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26513 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26514 int result;
26515 void *argp1 = 0 ;
26516 int res1 = 0 ;
26517 bool temp2 = false ;
26518 PyObject * obj0 = 0 ;
26519 PyObject * obj1 = 0 ;
26520 char * kwnames[] = {
26521 (char *) "self",(char *) "tz", NULL
26522 };
26523
26524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
26525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26526 if (!SWIG_IsOK(res1)) {
26527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26528 }
26529 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26530 if (obj1) {
26531 {
26532 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26533 temp2 = true;
26534 }
26535 }
26536 {
26537 PyThreadState* __tstate = wxPyBeginAllowThreads();
26538 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 resultobj = SWIG_From_int(static_cast< int >(result));
26543 {
26544 if (temp2) delete arg2;
26545 }
26546 return resultobj;
26547 fail:
26548 {
26549 if (temp2) delete arg2;
26550 }
26551 return NULL;
26552 }
26553
26554
26555 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26556 PyObject *resultobj = 0;
26557 wxDateTime *arg1 = (wxDateTime *) 0 ;
26558 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26559 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26560 int result;
26561 void *argp1 = 0 ;
26562 int res1 = 0 ;
26563 bool temp2 = false ;
26564 PyObject * obj0 = 0 ;
26565 PyObject * obj1 = 0 ;
26566 char * kwnames[] = {
26567 (char *) "self",(char *) "tz", NULL
26568 };
26569
26570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
26571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26572 if (!SWIG_IsOK(res1)) {
26573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26574 }
26575 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26576 if (obj1) {
26577 {
26578 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26579 temp2 = true;
26580 }
26581 }
26582 {
26583 PyThreadState* __tstate = wxPyBeginAllowThreads();
26584 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
26585 wxPyEndAllowThreads(__tstate);
26586 if (PyErr_Occurred()) SWIG_fail;
26587 }
26588 resultobj = SWIG_From_int(static_cast< int >(result));
26589 {
26590 if (temp2) delete arg2;
26591 }
26592 return resultobj;
26593 fail:
26594 {
26595 if (temp2) delete arg2;
26596 }
26597 return NULL;
26598 }
26599
26600
26601 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26602 PyObject *resultobj = 0;
26603 wxDateTime *arg1 = (wxDateTime *) 0 ;
26604 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26605 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26606 int result;
26607 void *argp1 = 0 ;
26608 int res1 = 0 ;
26609 bool temp2 = false ;
26610 PyObject * obj0 = 0 ;
26611 PyObject * obj1 = 0 ;
26612 char * kwnames[] = {
26613 (char *) "self",(char *) "tz", NULL
26614 };
26615
26616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
26617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26618 if (!SWIG_IsOK(res1)) {
26619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26620 }
26621 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26622 if (obj1) {
26623 {
26624 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26625 temp2 = true;
26626 }
26627 }
26628 {
26629 PyThreadState* __tstate = wxPyBeginAllowThreads();
26630 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
26631 wxPyEndAllowThreads(__tstate);
26632 if (PyErr_Occurred()) SWIG_fail;
26633 }
26634 resultobj = SWIG_From_int(static_cast< int >(result));
26635 {
26636 if (temp2) delete arg2;
26637 }
26638 return resultobj;
26639 fail:
26640 {
26641 if (temp2) delete arg2;
26642 }
26643 return NULL;
26644 }
26645
26646
26647 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26648 PyObject *resultobj = 0;
26649 wxDateTime *arg1 = (wxDateTime *) 0 ;
26650 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
26651 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
26652 int result;
26653 void *argp1 = 0 ;
26654 int res1 = 0 ;
26655 bool temp2 = false ;
26656 PyObject * obj0 = 0 ;
26657 PyObject * obj1 = 0 ;
26658 char * kwnames[] = {
26659 (char *) "self",(char *) "tz", NULL
26660 };
26661
26662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
26663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26664 if (!SWIG_IsOK(res1)) {
26665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26666 }
26667 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26668 if (obj1) {
26669 {
26670 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
26671 temp2 = true;
26672 }
26673 }
26674 {
26675 PyThreadState* __tstate = wxPyBeginAllowThreads();
26676 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
26677 wxPyEndAllowThreads(__tstate);
26678 if (PyErr_Occurred()) SWIG_fail;
26679 }
26680 resultobj = SWIG_From_int(static_cast< int >(result));
26681 {
26682 if (temp2) delete arg2;
26683 }
26684 return resultobj;
26685 fail:
26686 {
26687 if (temp2) delete arg2;
26688 }
26689 return NULL;
26690 }
26691
26692
26693 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26694 PyObject *resultobj = 0;
26695 wxDateTime *arg1 = (wxDateTime *) 0 ;
26696 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26697 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26698 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26699 int result;
26700 void *argp1 = 0 ;
26701 int res1 = 0 ;
26702 int val2 ;
26703 int ecode2 = 0 ;
26704 bool temp3 = false ;
26705 PyObject * obj0 = 0 ;
26706 PyObject * obj1 = 0 ;
26707 PyObject * obj2 = 0 ;
26708 char * kwnames[] = {
26709 (char *) "self",(char *) "flags",(char *) "tz", NULL
26710 };
26711
26712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26714 if (!SWIG_IsOK(res1)) {
26715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26716 }
26717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26718 if (obj1) {
26719 ecode2 = SWIG_AsVal_int(obj1, &val2);
26720 if (!SWIG_IsOK(ecode2)) {
26721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26722 }
26723 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26724 }
26725 if (obj2) {
26726 {
26727 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26728 temp3 = true;
26729 }
26730 }
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
26734 wxPyEndAllowThreads(__tstate);
26735 if (PyErr_Occurred()) SWIG_fail;
26736 }
26737 resultobj = SWIG_From_int(static_cast< int >(result));
26738 {
26739 if (temp3) delete arg3;
26740 }
26741 return resultobj;
26742 fail:
26743 {
26744 if (temp3) delete arg3;
26745 }
26746 return NULL;
26747 }
26748
26749
26750 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26751 PyObject *resultobj = 0;
26752 wxDateTime *arg1 = (wxDateTime *) 0 ;
26753 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
26754 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
26755 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
26756 int result;
26757 void *argp1 = 0 ;
26758 int res1 = 0 ;
26759 int val2 ;
26760 int ecode2 = 0 ;
26761 bool temp3 = false ;
26762 PyObject * obj0 = 0 ;
26763 PyObject * obj1 = 0 ;
26764 PyObject * obj2 = 0 ;
26765 char * kwnames[] = {
26766 (char *) "self",(char *) "flags",(char *) "tz", NULL
26767 };
26768
26769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26771 if (!SWIG_IsOK(res1)) {
26772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26773 }
26774 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26775 if (obj1) {
26776 ecode2 = SWIG_AsVal_int(obj1, &val2);
26777 if (!SWIG_IsOK(ecode2)) {
26778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
26779 }
26780 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
26781 }
26782 if (obj2) {
26783 {
26784 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
26785 temp3 = true;
26786 }
26787 }
26788 {
26789 PyThreadState* __tstate = wxPyBeginAllowThreads();
26790 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 resultobj = SWIG_From_int(static_cast< int >(result));
26795 {
26796 if (temp3) delete arg3;
26797 }
26798 return resultobj;
26799 fail:
26800 {
26801 if (temp3) delete arg3;
26802 }
26803 return NULL;
26804 }
26805
26806
26807 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26808 PyObject *resultobj = 0;
26809 wxDateTime *arg1 = (wxDateTime *) 0 ;
26810 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
26811 bool result;
26812 void *argp1 = 0 ;
26813 int res1 = 0 ;
26814 int val2 ;
26815 int ecode2 = 0 ;
26816 PyObject * obj0 = 0 ;
26817 PyObject * obj1 = 0 ;
26818 char * kwnames[] = {
26819 (char *) "self",(char *) "country", NULL
26820 };
26821
26822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
26823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26824 if (!SWIG_IsOK(res1)) {
26825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26826 }
26827 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26828 if (obj1) {
26829 ecode2 = SWIG_AsVal_int(obj1, &val2);
26830 if (!SWIG_IsOK(ecode2)) {
26831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
26832 }
26833 arg2 = static_cast< wxDateTime::Country >(val2);
26834 }
26835 {
26836 PyThreadState* __tstate = wxPyBeginAllowThreads();
26837 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
26838 wxPyEndAllowThreads(__tstate);
26839 if (PyErr_Occurred()) SWIG_fail;
26840 }
26841 {
26842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26843 }
26844 return resultobj;
26845 fail:
26846 return NULL;
26847 }
26848
26849
26850 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26851 PyObject *resultobj = 0;
26852 wxDateTime *arg1 = (wxDateTime *) 0 ;
26853 wxDateTime *arg2 = 0 ;
26854 bool result;
26855 void *argp1 = 0 ;
26856 int res1 = 0 ;
26857 void *argp2 = 0 ;
26858 int res2 = 0 ;
26859 PyObject * obj0 = 0 ;
26860 PyObject * obj1 = 0 ;
26861 char * kwnames[] = {
26862 (char *) "self",(char *) "datetime", NULL
26863 };
26864
26865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
26866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26867 if (!SWIG_IsOK(res1)) {
26868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26869 }
26870 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26871 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26872 if (!SWIG_IsOK(res2)) {
26873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26874 }
26875 if (!argp2) {
26876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26877 }
26878 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26879 {
26880 PyThreadState* __tstate = wxPyBeginAllowThreads();
26881 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 {
26886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26887 }
26888 return resultobj;
26889 fail:
26890 return NULL;
26891 }
26892
26893
26894 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26895 PyObject *resultobj = 0;
26896 wxDateTime *arg1 = (wxDateTime *) 0 ;
26897 wxDateTime *arg2 = 0 ;
26898 bool result;
26899 void *argp1 = 0 ;
26900 int res1 = 0 ;
26901 void *argp2 = 0 ;
26902 int res2 = 0 ;
26903 PyObject * obj0 = 0 ;
26904 PyObject * obj1 = 0 ;
26905 char * kwnames[] = {
26906 (char *) "self",(char *) "datetime", NULL
26907 };
26908
26909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
26910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26911 if (!SWIG_IsOK(res1)) {
26912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26913 }
26914 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26915 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26916 if (!SWIG_IsOK(res2)) {
26917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26918 }
26919 if (!argp2) {
26920 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26921 }
26922 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
26926 wxPyEndAllowThreads(__tstate);
26927 if (PyErr_Occurred()) SWIG_fail;
26928 }
26929 {
26930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26931 }
26932 return resultobj;
26933 fail:
26934 return NULL;
26935 }
26936
26937
26938 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26939 PyObject *resultobj = 0;
26940 wxDateTime *arg1 = (wxDateTime *) 0 ;
26941 wxDateTime *arg2 = 0 ;
26942 bool result;
26943 void *argp1 = 0 ;
26944 int res1 = 0 ;
26945 void *argp2 = 0 ;
26946 int res2 = 0 ;
26947 PyObject * obj0 = 0 ;
26948 PyObject * obj1 = 0 ;
26949 char * kwnames[] = {
26950 (char *) "self",(char *) "datetime", NULL
26951 };
26952
26953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
26954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26955 if (!SWIG_IsOK(res1)) {
26956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26957 }
26958 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26960 if (!SWIG_IsOK(res2)) {
26961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26962 }
26963 if (!argp2) {
26964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26965 }
26966 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26967 {
26968 PyThreadState* __tstate = wxPyBeginAllowThreads();
26969 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
26970 wxPyEndAllowThreads(__tstate);
26971 if (PyErr_Occurred()) SWIG_fail;
26972 }
26973 {
26974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26975 }
26976 return resultobj;
26977 fail:
26978 return NULL;
26979 }
26980
26981
26982 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26983 PyObject *resultobj = 0;
26984 wxDateTime *arg1 = (wxDateTime *) 0 ;
26985 wxDateTime *arg2 = 0 ;
26986 wxDateTime *arg3 = 0 ;
26987 bool result;
26988 void *argp1 = 0 ;
26989 int res1 = 0 ;
26990 void *argp2 = 0 ;
26991 int res2 = 0 ;
26992 void *argp3 = 0 ;
26993 int res3 = 0 ;
26994 PyObject * obj0 = 0 ;
26995 PyObject * obj1 = 0 ;
26996 PyObject * obj2 = 0 ;
26997 char * kwnames[] = {
26998 (char *) "self",(char *) "t1",(char *) "t2", NULL
26999 };
27000
27001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27003 if (!SWIG_IsOK(res1)) {
27004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27005 }
27006 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27008 if (!SWIG_IsOK(res2)) {
27009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27010 }
27011 if (!argp2) {
27012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27013 }
27014 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27015 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27016 if (!SWIG_IsOK(res3)) {
27017 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27018 }
27019 if (!argp3) {
27020 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27021 }
27022 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27026 wxPyEndAllowThreads(__tstate);
27027 if (PyErr_Occurred()) SWIG_fail;
27028 }
27029 {
27030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27031 }
27032 return resultobj;
27033 fail:
27034 return NULL;
27035 }
27036
27037
27038 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27039 PyObject *resultobj = 0;
27040 wxDateTime *arg1 = (wxDateTime *) 0 ;
27041 wxDateTime *arg2 = 0 ;
27042 wxDateTime *arg3 = 0 ;
27043 bool result;
27044 void *argp1 = 0 ;
27045 int res1 = 0 ;
27046 void *argp2 = 0 ;
27047 int res2 = 0 ;
27048 void *argp3 = 0 ;
27049 int res3 = 0 ;
27050 PyObject * obj0 = 0 ;
27051 PyObject * obj1 = 0 ;
27052 PyObject * obj2 = 0 ;
27053 char * kwnames[] = {
27054 (char *) "self",(char *) "t1",(char *) "t2", NULL
27055 };
27056
27057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27059 if (!SWIG_IsOK(res1)) {
27060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27061 }
27062 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27063 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27064 if (!SWIG_IsOK(res2)) {
27065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27066 }
27067 if (!argp2) {
27068 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27069 }
27070 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27071 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
27072 if (!SWIG_IsOK(res3)) {
27073 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27074 }
27075 if (!argp3) {
27076 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
27077 }
27078 arg3 = reinterpret_cast< wxDateTime * >(argp3);
27079 {
27080 PyThreadState* __tstate = wxPyBeginAllowThreads();
27081 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 {
27086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27087 }
27088 return resultobj;
27089 fail:
27090 return NULL;
27091 }
27092
27093
27094 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27095 PyObject *resultobj = 0;
27096 wxDateTime *arg1 = (wxDateTime *) 0 ;
27097 wxDateTime *arg2 = 0 ;
27098 bool result;
27099 void *argp1 = 0 ;
27100 int res1 = 0 ;
27101 void *argp2 = 0 ;
27102 int res2 = 0 ;
27103 PyObject * obj0 = 0 ;
27104 PyObject * obj1 = 0 ;
27105 char * kwnames[] = {
27106 (char *) "self",(char *) "dt", NULL
27107 };
27108
27109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
27110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27111 if (!SWIG_IsOK(res1)) {
27112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27113 }
27114 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27116 if (!SWIG_IsOK(res2)) {
27117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27118 }
27119 if (!argp2) {
27120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27121 }
27122 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 {
27130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27131 }
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj = 0;
27140 wxDateTime *arg1 = (wxDateTime *) 0 ;
27141 wxDateTime *arg2 = 0 ;
27142 bool result;
27143 void *argp1 = 0 ;
27144 int res1 = 0 ;
27145 void *argp2 = 0 ;
27146 int res2 = 0 ;
27147 PyObject * obj0 = 0 ;
27148 PyObject * obj1 = 0 ;
27149 char * kwnames[] = {
27150 (char *) "self",(char *) "dt", NULL
27151 };
27152
27153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
27154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27155 if (!SWIG_IsOK(res1)) {
27156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27157 }
27158 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27159 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27160 if (!SWIG_IsOK(res2)) {
27161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27162 }
27163 if (!argp2) {
27164 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27165 }
27166 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27167 {
27168 PyThreadState* __tstate = wxPyBeginAllowThreads();
27169 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
27170 wxPyEndAllowThreads(__tstate);
27171 if (PyErr_Occurred()) SWIG_fail;
27172 }
27173 {
27174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27175 }
27176 return resultobj;
27177 fail:
27178 return NULL;
27179 }
27180
27181
27182 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27183 PyObject *resultobj = 0;
27184 wxDateTime *arg1 = (wxDateTime *) 0 ;
27185 wxDateTime *arg2 = 0 ;
27186 wxTimeSpan *arg3 = 0 ;
27187 bool result;
27188 void *argp1 = 0 ;
27189 int res1 = 0 ;
27190 void *argp2 = 0 ;
27191 int res2 = 0 ;
27192 void *argp3 = 0 ;
27193 int res3 = 0 ;
27194 PyObject * obj0 = 0 ;
27195 PyObject * obj1 = 0 ;
27196 PyObject * obj2 = 0 ;
27197 char * kwnames[] = {
27198 (char *) "self",(char *) "dt",(char *) "ts", NULL
27199 };
27200
27201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27203 if (!SWIG_IsOK(res1)) {
27204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27205 }
27206 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27207 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27208 if (!SWIG_IsOK(res2)) {
27209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27210 }
27211 if (!argp2) {
27212 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27213 }
27214 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27215 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27216 if (!SWIG_IsOK(res3)) {
27217 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27218 }
27219 if (!argp3) {
27220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
27221 }
27222 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 {
27230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27231 }
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27239 PyObject *resultobj = 0;
27240 wxDateTime *arg1 = (wxDateTime *) 0 ;
27241 wxTimeSpan *arg2 = 0 ;
27242 wxDateTime *result = 0 ;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 void *argp2 = 0 ;
27246 int res2 = 0 ;
27247 PyObject * obj0 = 0 ;
27248 PyObject * obj1 = 0 ;
27249 char * kwnames[] = {
27250 (char *) "self",(char *) "diff", NULL
27251 };
27252
27253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
27254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27255 if (!SWIG_IsOK(res1)) {
27256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27257 }
27258 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27259 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27260 if (!SWIG_IsOK(res2)) {
27261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27262 }
27263 if (!argp2) {
27264 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27265 }
27266 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 {
27270 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27271 result = (wxDateTime *) &_result_ref;
27272 }
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj = 0;
27285 wxDateTime *arg1 = (wxDateTime *) 0 ;
27286 wxDateSpan *arg2 = 0 ;
27287 wxDateTime *result = 0 ;
27288 void *argp1 = 0 ;
27289 int res1 = 0 ;
27290 void *argp2 = 0 ;
27291 int res2 = 0 ;
27292 PyObject * obj0 = 0 ;
27293 PyObject * obj1 = 0 ;
27294 char * kwnames[] = {
27295 (char *) "self",(char *) "diff", NULL
27296 };
27297
27298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
27299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27300 if (!SWIG_IsOK(res1)) {
27301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27302 }
27303 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27305 if (!SWIG_IsOK(res2)) {
27306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27307 }
27308 if (!argp2) {
27309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27310 }
27311 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 {
27315 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
27316 result = (wxDateTime *) &_result_ref;
27317 }
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27329 PyObject *resultobj = 0;
27330 wxDateTime *arg1 = (wxDateTime *) 0 ;
27331 wxTimeSpan *arg2 = 0 ;
27332 wxDateTime *result = 0 ;
27333 void *argp1 = 0 ;
27334 int res1 = 0 ;
27335 void *argp2 = 0 ;
27336 int res2 = 0 ;
27337 PyObject * obj0 = 0 ;
27338 PyObject * obj1 = 0 ;
27339 char * kwnames[] = {
27340 (char *) "self",(char *) "diff", NULL
27341 };
27342
27343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
27344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27345 if (!SWIG_IsOK(res1)) {
27346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27347 }
27348 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27350 if (!SWIG_IsOK(res2)) {
27351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27352 }
27353 if (!argp2) {
27354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27355 }
27356 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 {
27360 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27361 result = (wxDateTime *) &_result_ref;
27362 }
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27367 return resultobj;
27368 fail:
27369 return NULL;
27370 }
27371
27372
27373 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27374 PyObject *resultobj = 0;
27375 wxDateTime *arg1 = (wxDateTime *) 0 ;
27376 wxDateSpan *arg2 = 0 ;
27377 wxDateTime *result = 0 ;
27378 void *argp1 = 0 ;
27379 int res1 = 0 ;
27380 void *argp2 = 0 ;
27381 int res2 = 0 ;
27382 PyObject * obj0 = 0 ;
27383 PyObject * obj1 = 0 ;
27384 char * kwnames[] = {
27385 (char *) "self",(char *) "diff", NULL
27386 };
27387
27388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
27389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27390 if (!SWIG_IsOK(res1)) {
27391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
27392 }
27393 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27394 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27395 if (!SWIG_IsOK(res2)) {
27396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27397 }
27398 if (!argp2) {
27399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27400 }
27401 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27402 {
27403 PyThreadState* __tstate = wxPyBeginAllowThreads();
27404 {
27405 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
27406 result = (wxDateTime *) &_result_ref;
27407 }
27408 wxPyEndAllowThreads(__tstate);
27409 if (PyErr_Occurred()) SWIG_fail;
27410 }
27411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27412 return resultobj;
27413 fail:
27414 return NULL;
27415 }
27416
27417
27418 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27419 PyObject *resultobj = 0;
27420 wxDateTime *arg1 = (wxDateTime *) 0 ;
27421 wxDateTime *arg2 = 0 ;
27422 wxTimeSpan result;
27423 void *argp1 = 0 ;
27424 int res1 = 0 ;
27425 void *argp2 = 0 ;
27426 int res2 = 0 ;
27427 PyObject * obj0 = 0 ;
27428 PyObject * obj1 = 0 ;
27429 char * kwnames[] = {
27430 (char *) "self",(char *) "dt", NULL
27431 };
27432
27433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27435 if (!SWIG_IsOK(res1)) {
27436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27437 }
27438 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27439 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27440 if (!SWIG_IsOK(res2)) {
27441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27442 }
27443 if (!argp2) {
27444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27445 }
27446 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27447 {
27448 PyThreadState* __tstate = wxPyBeginAllowThreads();
27449 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
27450 wxPyEndAllowThreads(__tstate);
27451 if (PyErr_Occurred()) SWIG_fail;
27452 }
27453 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27454 return resultobj;
27455 fail:
27456 return NULL;
27457 }
27458
27459
27460 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27461 PyObject *resultobj = 0;
27462 wxDateTime *arg1 = (wxDateTime *) 0 ;
27463 wxTimeSpan *arg2 = 0 ;
27464 wxDateTime *result = 0 ;
27465 void *argp1 = 0 ;
27466 int res1 = 0 ;
27467 void *argp2 = 0 ;
27468 int res2 = 0 ;
27469
27470 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27472 if (!SWIG_IsOK(res1)) {
27473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27474 }
27475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27476 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27477 if (!SWIG_IsOK(res2)) {
27478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27479 }
27480 if (!argp2) {
27481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27482 }
27483 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27484 {
27485 PyThreadState* __tstate = wxPyBeginAllowThreads();
27486 {
27487 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27488 result = (wxDateTime *) &_result_ref;
27489 }
27490 wxPyEndAllowThreads(__tstate);
27491 if (PyErr_Occurred()) SWIG_fail;
27492 }
27493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27501 PyObject *resultobj = 0;
27502 wxDateTime *arg1 = (wxDateTime *) 0 ;
27503 wxDateSpan *arg2 = 0 ;
27504 wxDateTime *result = 0 ;
27505 void *argp1 = 0 ;
27506 int res1 = 0 ;
27507 void *argp2 = 0 ;
27508 int res2 = 0 ;
27509
27510 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27512 if (!SWIG_IsOK(res1)) {
27513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27514 }
27515 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27516 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27517 if (!SWIG_IsOK(res2)) {
27518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27519 }
27520 if (!argp2) {
27521 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27522 }
27523 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27524 {
27525 PyThreadState* __tstate = wxPyBeginAllowThreads();
27526 {
27527 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
27528 result = (wxDateTime *) &_result_ref;
27529 }
27530 wxPyEndAllowThreads(__tstate);
27531 if (PyErr_Occurred()) SWIG_fail;
27532 }
27533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27534 return resultobj;
27535 fail:
27536 return NULL;
27537 }
27538
27539
27540 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
27541 int argc;
27542 PyObject *argv[3];
27543
27544 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
27545 --argc;
27546 if (argc == 2) {
27547 int _v = 0;
27548 {
27549 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27550 _v = SWIG_CheckState(res);
27551 }
27552 if (!_v) goto check_1;
27553 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
27554 }
27555 check_1:
27556
27557 if (argc == 2) {
27558 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
27559 }
27560
27561 fail:
27562 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27568 PyObject *resultobj = 0;
27569 wxDateTime *arg1 = (wxDateTime *) 0 ;
27570 wxTimeSpan *arg2 = 0 ;
27571 wxDateTime *result = 0 ;
27572 void *argp1 = 0 ;
27573 int res1 = 0 ;
27574 void *argp2 = 0 ;
27575 int res2 = 0 ;
27576
27577 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27579 if (!SWIG_IsOK(res1)) {
27580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27581 }
27582 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27583 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27584 if (!SWIG_IsOK(res2)) {
27585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27586 }
27587 if (!argp2) {
27588 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27589 }
27590 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27591 {
27592 PyThreadState* __tstate = wxPyBeginAllowThreads();
27593 {
27594 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27595 result = (wxDateTime *) &_result_ref;
27596 }
27597 wxPyEndAllowThreads(__tstate);
27598 if (PyErr_Occurred()) SWIG_fail;
27599 }
27600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27601 return resultobj;
27602 fail:
27603 return NULL;
27604 }
27605
27606
27607 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27608 PyObject *resultobj = 0;
27609 wxDateTime *arg1 = (wxDateTime *) 0 ;
27610 wxDateSpan *arg2 = 0 ;
27611 wxDateTime *result = 0 ;
27612 void *argp1 = 0 ;
27613 int res1 = 0 ;
27614 void *argp2 = 0 ;
27615 int res2 = 0 ;
27616
27617 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
27619 if (!SWIG_IsOK(res1)) {
27620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27621 }
27622 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27623 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27624 if (!SWIG_IsOK(res2)) {
27625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27626 }
27627 if (!argp2) {
27628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27629 }
27630 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 {
27634 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
27635 result = (wxDateTime *) &_result_ref;
27636 }
27637 wxPyEndAllowThreads(__tstate);
27638 if (PyErr_Occurred()) SWIG_fail;
27639 }
27640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
27648 int argc;
27649 PyObject *argv[3];
27650
27651 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
27652 --argc;
27653 if (argc == 2) {
27654 int _v = 0;
27655 {
27656 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27657 _v = SWIG_CheckState(res);
27658 }
27659 if (!_v) goto check_1;
27660 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
27661 }
27662 check_1:
27663
27664 if (argc == 2) {
27665 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
27666 }
27667
27668 fail:
27669 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
27670 return NULL;
27671 }
27672
27673
27674 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27675 PyObject *resultobj = 0;
27676 wxDateTime *arg1 = (wxDateTime *) 0 ;
27677 wxTimeSpan *arg2 = 0 ;
27678 wxDateTime result;
27679 void *argp1 = 0 ;
27680 int res1 = 0 ;
27681 void *argp2 = 0 ;
27682 int res2 = 0 ;
27683
27684 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27686 if (!SWIG_IsOK(res1)) {
27687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27688 }
27689 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27690 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27691 if (!SWIG_IsOK(res2)) {
27692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27693 }
27694 if (!argp2) {
27695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27696 }
27697 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27698 {
27699 PyThreadState* __tstate = wxPyBeginAllowThreads();
27700 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
27701 wxPyEndAllowThreads(__tstate);
27702 if (PyErr_Occurred()) SWIG_fail;
27703 }
27704 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27712 PyObject *resultobj = 0;
27713 wxDateTime *arg1 = (wxDateTime *) 0 ;
27714 wxDateSpan *arg2 = 0 ;
27715 wxDateTime result;
27716 void *argp1 = 0 ;
27717 int res1 = 0 ;
27718 void *argp2 = 0 ;
27719 int res2 = 0 ;
27720
27721 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27723 if (!SWIG_IsOK(res1)) {
27724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27725 }
27726 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27727 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27728 if (!SWIG_IsOK(res2)) {
27729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27730 }
27731 if (!argp2) {
27732 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27733 }
27734 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27735 {
27736 PyThreadState* __tstate = wxPyBeginAllowThreads();
27737 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
27738 wxPyEndAllowThreads(__tstate);
27739 if (PyErr_Occurred()) SWIG_fail;
27740 }
27741 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27742 return resultobj;
27743 fail:
27744 return NULL;
27745 }
27746
27747
27748 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
27749 int argc;
27750 PyObject *argv[3];
27751
27752 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
27753 --argc;
27754 if (argc == 2) {
27755 int _v = 0;
27756 {
27757 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27758 _v = SWIG_CheckState(res);
27759 }
27760 if (!_v) goto check_1;
27761 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
27762 }
27763 check_1:
27764
27765 if (argc == 2) {
27766 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
27767 }
27768
27769 fail:
27770 Py_INCREF(Py_NotImplemented);
27771 return Py_NotImplemented;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27776 PyObject *resultobj = 0;
27777 wxDateTime *arg1 = (wxDateTime *) 0 ;
27778 wxDateTime *arg2 = 0 ;
27779 wxTimeSpan result;
27780 void *argp1 = 0 ;
27781 int res1 = 0 ;
27782 void *argp2 = 0 ;
27783 int res2 = 0 ;
27784
27785 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27787 if (!SWIG_IsOK(res1)) {
27788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27789 }
27790 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27791 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27792 if (!SWIG_IsOK(res2)) {
27793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27794 }
27795 if (!argp2) {
27796 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27797 }
27798 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27799 {
27800 PyThreadState* __tstate = wxPyBeginAllowThreads();
27801 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
27802 wxPyEndAllowThreads(__tstate);
27803 if (PyErr_Occurred()) SWIG_fail;
27804 }
27805 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27806 return resultobj;
27807 fail:
27808 return NULL;
27809 }
27810
27811
27812 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27813 PyObject *resultobj = 0;
27814 wxDateTime *arg1 = (wxDateTime *) 0 ;
27815 wxTimeSpan *arg2 = 0 ;
27816 wxDateTime result;
27817 void *argp1 = 0 ;
27818 int res1 = 0 ;
27819 void *argp2 = 0 ;
27820 int res2 = 0 ;
27821
27822 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27824 if (!SWIG_IsOK(res1)) {
27825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27826 }
27827 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27828 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27829 if (!SWIG_IsOK(res2)) {
27830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27831 }
27832 if (!argp2) {
27833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27834 }
27835 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
27839 wxPyEndAllowThreads(__tstate);
27840 if (PyErr_Occurred()) SWIG_fail;
27841 }
27842 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27843 return resultobj;
27844 fail:
27845 return NULL;
27846 }
27847
27848
27849 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
27850 PyObject *resultobj = 0;
27851 wxDateTime *arg1 = (wxDateTime *) 0 ;
27852 wxDateSpan *arg2 = 0 ;
27853 wxDateTime result;
27854 void *argp1 = 0 ;
27855 int res1 = 0 ;
27856 void *argp2 = 0 ;
27857 int res2 = 0 ;
27858
27859 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
27860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27861 if (!SWIG_IsOK(res1)) {
27862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27863 }
27864 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27865 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
27866 if (!SWIG_IsOK(res2)) {
27867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27868 }
27869 if (!argp2) {
27870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
27871 }
27872 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
27887 int argc;
27888 PyObject *argv[3];
27889
27890 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
27891 --argc;
27892 if (argc == 2) {
27893 int _v = 0;
27894 {
27895 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
27896 _v = SWIG_CheckState(res);
27897 }
27898 if (!_v) goto check_1;
27899 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
27900 }
27901 check_1:
27902
27903 if (argc == 2) {
27904 int _v = 0;
27905 {
27906 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
27907 _v = SWIG_CheckState(res);
27908 }
27909 if (!_v) goto check_2;
27910 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
27911 }
27912 check_2:
27913
27914 if (argc == 2) {
27915 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
27916 }
27917
27918 fail:
27919 Py_INCREF(Py_NotImplemented);
27920 return Py_NotImplemented;
27921 }
27922
27923
27924 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27925 PyObject *resultobj = 0;
27926 wxDateTime *arg1 = (wxDateTime *) 0 ;
27927 wxDateTime *arg2 = (wxDateTime *) 0 ;
27928 bool result;
27929 void *argp1 = 0 ;
27930 int res1 = 0 ;
27931 void *argp2 = 0 ;
27932 int res2 = 0 ;
27933 PyObject * obj0 = 0 ;
27934 PyObject * obj1 = 0 ;
27935 char * kwnames[] = {
27936 (char *) "self",(char *) "other", NULL
27937 };
27938
27939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
27940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27941 if (!SWIG_IsOK(res1)) {
27942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27943 }
27944 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27945 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27946 if (!SWIG_IsOK(res2)) {
27947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27948 }
27949 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27950 {
27951 PyThreadState* __tstate = wxPyBeginAllowThreads();
27952 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 {
27957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27958 }
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj = 0;
27967 wxDateTime *arg1 = (wxDateTime *) 0 ;
27968 wxDateTime *arg2 = (wxDateTime *) 0 ;
27969 bool result;
27970 void *argp1 = 0 ;
27971 int res1 = 0 ;
27972 void *argp2 = 0 ;
27973 int res2 = 0 ;
27974 PyObject * obj0 = 0 ;
27975 PyObject * obj1 = 0 ;
27976 char * kwnames[] = {
27977 (char *) "self",(char *) "other", NULL
27978 };
27979
27980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
27981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27982 if (!SWIG_IsOK(res1)) {
27983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27984 }
27985 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27987 if (!SWIG_IsOK(res2)) {
27988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27989 }
27990 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27991 {
27992 PyThreadState* __tstate = wxPyBeginAllowThreads();
27993 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
27994 wxPyEndAllowThreads(__tstate);
27995 if (PyErr_Occurred()) SWIG_fail;
27996 }
27997 {
27998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27999 }
28000 return resultobj;
28001 fail:
28002 return NULL;
28003 }
28004
28005
28006 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28007 PyObject *resultobj = 0;
28008 wxDateTime *arg1 = (wxDateTime *) 0 ;
28009 wxDateTime *arg2 = (wxDateTime *) 0 ;
28010 bool result;
28011 void *argp1 = 0 ;
28012 int res1 = 0 ;
28013 void *argp2 = 0 ;
28014 int res2 = 0 ;
28015 PyObject * obj0 = 0 ;
28016 PyObject * obj1 = 0 ;
28017 char * kwnames[] = {
28018 (char *) "self",(char *) "other", NULL
28019 };
28020
28021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28023 if (!SWIG_IsOK(res1)) {
28024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28025 }
28026 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28027 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28028 if (!SWIG_IsOK(res2)) {
28029 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28030 }
28031 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28032 {
28033 PyThreadState* __tstate = wxPyBeginAllowThreads();
28034 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
28035 wxPyEndAllowThreads(__tstate);
28036 if (PyErr_Occurred()) SWIG_fail;
28037 }
28038 {
28039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28040 }
28041 return resultobj;
28042 fail:
28043 return NULL;
28044 }
28045
28046
28047 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28048 PyObject *resultobj = 0;
28049 wxDateTime *arg1 = (wxDateTime *) 0 ;
28050 wxDateTime *arg2 = (wxDateTime *) 0 ;
28051 bool result;
28052 void *argp1 = 0 ;
28053 int res1 = 0 ;
28054 void *argp2 = 0 ;
28055 int res2 = 0 ;
28056 PyObject * obj0 = 0 ;
28057 PyObject * obj1 = 0 ;
28058 char * kwnames[] = {
28059 (char *) "self",(char *) "other", NULL
28060 };
28061
28062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28064 if (!SWIG_IsOK(res1)) {
28065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28066 }
28067 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28069 if (!SWIG_IsOK(res2)) {
28070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28071 }
28072 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28073 {
28074 PyThreadState* __tstate = wxPyBeginAllowThreads();
28075 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
28076 wxPyEndAllowThreads(__tstate);
28077 if (PyErr_Occurred()) SWIG_fail;
28078 }
28079 {
28080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28081 }
28082 return resultobj;
28083 fail:
28084 return NULL;
28085 }
28086
28087
28088 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28089 PyObject *resultobj = 0;
28090 wxDateTime *arg1 = (wxDateTime *) 0 ;
28091 wxDateTime *arg2 = (wxDateTime *) 0 ;
28092 bool result;
28093 void *argp1 = 0 ;
28094 int res1 = 0 ;
28095 void *argp2 = 0 ;
28096 int res2 = 0 ;
28097 PyObject * obj0 = 0 ;
28098 PyObject * obj1 = 0 ;
28099 char * kwnames[] = {
28100 (char *) "self",(char *) "other", NULL
28101 };
28102
28103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28105 if (!SWIG_IsOK(res1)) {
28106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28107 }
28108 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28109 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28110 if (!SWIG_IsOK(res2)) {
28111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28112 }
28113 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28114 {
28115 PyThreadState* __tstate = wxPyBeginAllowThreads();
28116 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
28117 wxPyEndAllowThreads(__tstate);
28118 if (PyErr_Occurred()) SWIG_fail;
28119 }
28120 {
28121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28122 }
28123 return resultobj;
28124 fail:
28125 return NULL;
28126 }
28127
28128
28129 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28130 PyObject *resultobj = 0;
28131 wxDateTime *arg1 = (wxDateTime *) 0 ;
28132 wxDateTime *arg2 = (wxDateTime *) 0 ;
28133 bool result;
28134 void *argp1 = 0 ;
28135 int res1 = 0 ;
28136 void *argp2 = 0 ;
28137 int res2 = 0 ;
28138 PyObject * obj0 = 0 ;
28139 PyObject * obj1 = 0 ;
28140 char * kwnames[] = {
28141 (char *) "self",(char *) "other", NULL
28142 };
28143
28144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28146 if (!SWIG_IsOK(res1)) {
28147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
28148 }
28149 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28150 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
28151 if (!SWIG_IsOK(res2)) {
28152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
28153 }
28154 arg2 = reinterpret_cast< wxDateTime * >(argp2);
28155 {
28156 PyThreadState* __tstate = wxPyBeginAllowThreads();
28157 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 {
28162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28163 }
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28171 PyObject *resultobj = 0;
28172 wxDateTime *arg1 = (wxDateTime *) 0 ;
28173 wxString *arg2 = 0 ;
28174 int result;
28175 void *argp1 = 0 ;
28176 int res1 = 0 ;
28177 bool temp2 = false ;
28178 PyObject * obj0 = 0 ;
28179 PyObject * obj1 = 0 ;
28180 char * kwnames[] = {
28181 (char *) "self",(char *) "date", NULL
28182 };
28183
28184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
28185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28186 if (!SWIG_IsOK(res1)) {
28187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
28188 }
28189 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28190 {
28191 arg2 = wxString_in_helper(obj1);
28192 if (arg2 == NULL) SWIG_fail;
28193 temp2 = true;
28194 }
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 resultobj = SWIG_From_int(static_cast< int >(result));
28202 {
28203 if (temp2)
28204 delete arg2;
28205 }
28206 return resultobj;
28207 fail:
28208 {
28209 if (temp2)
28210 delete arg2;
28211 }
28212 return NULL;
28213 }
28214
28215
28216 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28217 PyObject *resultobj = 0;
28218 wxDateTime *arg1 = (wxDateTime *) 0 ;
28219 wxString *arg2 = 0 ;
28220 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
28221 wxString *arg3 = (wxString *) &arg3_defvalue ;
28222 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
28223 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
28224 int result;
28225 void *argp1 = 0 ;
28226 int res1 = 0 ;
28227 bool temp2 = false ;
28228 bool temp3 = false ;
28229 void *argp4 = 0 ;
28230 int res4 = 0 ;
28231 PyObject * obj0 = 0 ;
28232 PyObject * obj1 = 0 ;
28233 PyObject * obj2 = 0 ;
28234 PyObject * obj3 = 0 ;
28235 char * kwnames[] = {
28236 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
28237 };
28238
28239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28241 if (!SWIG_IsOK(res1)) {
28242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
28243 }
28244 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28245 {
28246 arg2 = wxString_in_helper(obj1);
28247 if (arg2 == NULL) SWIG_fail;
28248 temp2 = true;
28249 }
28250 if (obj2) {
28251 {
28252 arg3 = wxString_in_helper(obj2);
28253 if (arg3 == NULL) SWIG_fail;
28254 temp3 = true;
28255 }
28256 }
28257 if (obj3) {
28258 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
28259 if (!SWIG_IsOK(res4)) {
28260 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28261 }
28262 if (!argp4) {
28263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
28264 }
28265 arg4 = reinterpret_cast< wxDateTime * >(argp4);
28266 }
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 resultobj = SWIG_From_int(static_cast< int >(result));
28274 {
28275 if (temp2)
28276 delete arg2;
28277 }
28278 {
28279 if (temp3)
28280 delete arg3;
28281 }
28282 return resultobj;
28283 fail:
28284 {
28285 if (temp2)
28286 delete arg2;
28287 }
28288 {
28289 if (temp3)
28290 delete arg3;
28291 }
28292 return NULL;
28293 }
28294
28295
28296 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28297 PyObject *resultobj = 0;
28298 wxDateTime *arg1 = (wxDateTime *) 0 ;
28299 wxString *arg2 = 0 ;
28300 int result;
28301 void *argp1 = 0 ;
28302 int res1 = 0 ;
28303 bool temp2 = false ;
28304 PyObject * obj0 = 0 ;
28305 PyObject * obj1 = 0 ;
28306 char * kwnames[] = {
28307 (char *) "self",(char *) "datetime", NULL
28308 };
28309
28310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
28311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28312 if (!SWIG_IsOK(res1)) {
28313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28314 }
28315 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28316 {
28317 arg2 = wxString_in_helper(obj1);
28318 if (arg2 == NULL) SWIG_fail;
28319 temp2 = true;
28320 }
28321 {
28322 PyThreadState* __tstate = wxPyBeginAllowThreads();
28323 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
28324 wxPyEndAllowThreads(__tstate);
28325 if (PyErr_Occurred()) SWIG_fail;
28326 }
28327 resultobj = SWIG_From_int(static_cast< int >(result));
28328 {
28329 if (temp2)
28330 delete arg2;
28331 }
28332 return resultobj;
28333 fail:
28334 {
28335 if (temp2)
28336 delete arg2;
28337 }
28338 return NULL;
28339 }
28340
28341
28342 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28343 PyObject *resultobj = 0;
28344 wxDateTime *arg1 = (wxDateTime *) 0 ;
28345 wxString *arg2 = 0 ;
28346 int result;
28347 void *argp1 = 0 ;
28348 int res1 = 0 ;
28349 bool temp2 = false ;
28350 PyObject * obj0 = 0 ;
28351 PyObject * obj1 = 0 ;
28352 char * kwnames[] = {
28353 (char *) "self",(char *) "date", NULL
28354 };
28355
28356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
28357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28358 if (!SWIG_IsOK(res1)) {
28359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
28360 }
28361 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28362 {
28363 arg2 = wxString_in_helper(obj1);
28364 if (arg2 == NULL) SWIG_fail;
28365 temp2 = true;
28366 }
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 resultobj = SWIG_From_int(static_cast< int >(result));
28374 {
28375 if (temp2)
28376 delete arg2;
28377 }
28378 return resultobj;
28379 fail:
28380 {
28381 if (temp2)
28382 delete arg2;
28383 }
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28389 PyObject *resultobj = 0;
28390 wxDateTime *arg1 = (wxDateTime *) 0 ;
28391 wxString *arg2 = 0 ;
28392 int result;
28393 void *argp1 = 0 ;
28394 int res1 = 0 ;
28395 bool temp2 = false ;
28396 PyObject * obj0 = 0 ;
28397 PyObject * obj1 = 0 ;
28398 char * kwnames[] = {
28399 (char *) "self",(char *) "time", NULL
28400 };
28401
28402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
28403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28404 if (!SWIG_IsOK(res1)) {
28405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
28406 }
28407 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28408 {
28409 arg2 = wxString_in_helper(obj1);
28410 if (arg2 == NULL) SWIG_fail;
28411 temp2 = true;
28412 }
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 resultobj = SWIG_From_int(static_cast< int >(result));
28420 {
28421 if (temp2)
28422 delete arg2;
28423 }
28424 return resultobj;
28425 fail:
28426 {
28427 if (temp2)
28428 delete arg2;
28429 }
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28435 PyObject *resultobj = 0;
28436 wxDateTime *arg1 = (wxDateTime *) 0 ;
28437 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
28438 wxString *arg2 = (wxString *) &arg2_defvalue ;
28439 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
28440 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
28441 wxString result;
28442 void *argp1 = 0 ;
28443 int res1 = 0 ;
28444 bool temp2 = false ;
28445 bool temp3 = false ;
28446 PyObject * obj0 = 0 ;
28447 PyObject * obj1 = 0 ;
28448 PyObject * obj2 = 0 ;
28449 char * kwnames[] = {
28450 (char *) "self",(char *) "format",(char *) "tz", NULL
28451 };
28452
28453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28455 if (!SWIG_IsOK(res1)) {
28456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28457 }
28458 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28459 if (obj1) {
28460 {
28461 arg2 = wxString_in_helper(obj1);
28462 if (arg2 == NULL) SWIG_fail;
28463 temp2 = true;
28464 }
28465 }
28466 if (obj2) {
28467 {
28468 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
28469 temp3 = true;
28470 }
28471 }
28472 {
28473 PyThreadState* __tstate = wxPyBeginAllowThreads();
28474 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
28475 wxPyEndAllowThreads(__tstate);
28476 if (PyErr_Occurred()) SWIG_fail;
28477 }
28478 {
28479 #if wxUSE_UNICODE
28480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28481 #else
28482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28483 #endif
28484 }
28485 {
28486 if (temp2)
28487 delete arg2;
28488 }
28489 {
28490 if (temp3) delete arg3;
28491 }
28492 return resultobj;
28493 fail:
28494 {
28495 if (temp2)
28496 delete arg2;
28497 }
28498 {
28499 if (temp3) delete arg3;
28500 }
28501 return NULL;
28502 }
28503
28504
28505 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28506 PyObject *resultobj = 0;
28507 wxDateTime *arg1 = (wxDateTime *) 0 ;
28508 wxString result;
28509 void *argp1 = 0 ;
28510 int res1 = 0 ;
28511 PyObject *swig_obj[1] ;
28512
28513 if (!args) SWIG_fail;
28514 swig_obj[0] = args;
28515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28516 if (!SWIG_IsOK(res1)) {
28517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28518 }
28519 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28520 {
28521 PyThreadState* __tstate = wxPyBeginAllowThreads();
28522 result = ((wxDateTime const *)arg1)->FormatDate();
28523 wxPyEndAllowThreads(__tstate);
28524 if (PyErr_Occurred()) SWIG_fail;
28525 }
28526 {
28527 #if wxUSE_UNICODE
28528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28529 #else
28530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28531 #endif
28532 }
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28540 PyObject *resultobj = 0;
28541 wxDateTime *arg1 = (wxDateTime *) 0 ;
28542 wxString result;
28543 void *argp1 = 0 ;
28544 int res1 = 0 ;
28545 PyObject *swig_obj[1] ;
28546
28547 if (!args) SWIG_fail;
28548 swig_obj[0] = args;
28549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28550 if (!SWIG_IsOK(res1)) {
28551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28552 }
28553 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28554 {
28555 PyThreadState* __tstate = wxPyBeginAllowThreads();
28556 result = ((wxDateTime const *)arg1)->FormatTime();
28557 wxPyEndAllowThreads(__tstate);
28558 if (PyErr_Occurred()) SWIG_fail;
28559 }
28560 {
28561 #if wxUSE_UNICODE
28562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28563 #else
28564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28565 #endif
28566 }
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *resultobj = 0;
28575 wxDateTime *arg1 = (wxDateTime *) 0 ;
28576 wxString result;
28577 void *argp1 = 0 ;
28578 int res1 = 0 ;
28579 PyObject *swig_obj[1] ;
28580
28581 if (!args) SWIG_fail;
28582 swig_obj[0] = args;
28583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28586 }
28587 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 result = ((wxDateTime const *)arg1)->FormatISODate();
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 {
28595 #if wxUSE_UNICODE
28596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28597 #else
28598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28599 #endif
28600 }
28601 return resultobj;
28602 fail:
28603 return NULL;
28604 }
28605
28606
28607 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28608 PyObject *resultobj = 0;
28609 wxDateTime *arg1 = (wxDateTime *) 0 ;
28610 wxString result;
28611 void *argp1 = 0 ;
28612 int res1 = 0 ;
28613 PyObject *swig_obj[1] ;
28614
28615 if (!args) SWIG_fail;
28616 swig_obj[0] = args;
28617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
28618 if (!SWIG_IsOK(res1)) {
28619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
28620 }
28621 arg1 = reinterpret_cast< wxDateTime * >(argp1);
28622 {
28623 PyThreadState* __tstate = wxPyBeginAllowThreads();
28624 result = ((wxDateTime const *)arg1)->FormatISOTime();
28625 wxPyEndAllowThreads(__tstate);
28626 if (PyErr_Occurred()) SWIG_fail;
28627 }
28628 {
28629 #if wxUSE_UNICODE
28630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28631 #else
28632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28633 #endif
28634 }
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28642 PyObject *obj;
28643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28644 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
28645 return SWIG_Py_Void();
28646 }
28647
28648 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28649 return SWIG_Python_InitShadowInstance(args);
28650 }
28651
28652 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28653 PyObject *resultobj = 0;
28654 long arg1 ;
28655 wxTimeSpan result;
28656 long val1 ;
28657 int ecode1 = 0 ;
28658 PyObject * obj0 = 0 ;
28659 char * kwnames[] = {
28660 (char *) "ms", NULL
28661 };
28662
28663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
28664 ecode1 = SWIG_AsVal_long(obj0, &val1);
28665 if (!SWIG_IsOK(ecode1)) {
28666 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
28667 }
28668 arg1 = static_cast< long >(val1);
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 result = wxTimeSpan::Milliseconds(arg1);
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28683 PyObject *resultobj = 0;
28684 wxTimeSpan result;
28685
28686 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 result = wxTimeSpan::Millisecond();
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28701 PyObject *resultobj = 0;
28702 long arg1 ;
28703 wxTimeSpan result;
28704 long val1 ;
28705 int ecode1 = 0 ;
28706 PyObject * obj0 = 0 ;
28707 char * kwnames[] = {
28708 (char *) "sec", NULL
28709 };
28710
28711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
28712 ecode1 = SWIG_AsVal_long(obj0, &val1);
28713 if (!SWIG_IsOK(ecode1)) {
28714 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
28715 }
28716 arg1 = static_cast< long >(val1);
28717 {
28718 PyThreadState* __tstate = wxPyBeginAllowThreads();
28719 result = wxTimeSpan::Seconds(arg1);
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 PyObject *resultobj = 0;
28732 wxTimeSpan result;
28733
28734 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = wxTimeSpan::Second();
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28749 PyObject *resultobj = 0;
28750 long arg1 ;
28751 wxTimeSpan result;
28752 long val1 ;
28753 int ecode1 = 0 ;
28754 PyObject * obj0 = 0 ;
28755 char * kwnames[] = {
28756 (char *) "min", NULL
28757 };
28758
28759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
28760 ecode1 = SWIG_AsVal_long(obj0, &val1);
28761 if (!SWIG_IsOK(ecode1)) {
28762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
28763 }
28764 arg1 = static_cast< long >(val1);
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 result = wxTimeSpan::Minutes(arg1);
28768 wxPyEndAllowThreads(__tstate);
28769 if (PyErr_Occurred()) SWIG_fail;
28770 }
28771 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28779 PyObject *resultobj = 0;
28780 wxTimeSpan result;
28781
28782 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
28783 {
28784 PyThreadState* __tstate = wxPyBeginAllowThreads();
28785 result = wxTimeSpan::Minute();
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28797 PyObject *resultobj = 0;
28798 long arg1 ;
28799 wxTimeSpan result;
28800 long val1 ;
28801 int ecode1 = 0 ;
28802 PyObject * obj0 = 0 ;
28803 char * kwnames[] = {
28804 (char *) "hours", NULL
28805 };
28806
28807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
28808 ecode1 = SWIG_AsVal_long(obj0, &val1);
28809 if (!SWIG_IsOK(ecode1)) {
28810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
28811 }
28812 arg1 = static_cast< long >(val1);
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 result = wxTimeSpan::Hours(arg1);
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28827 PyObject *resultobj = 0;
28828 wxTimeSpan result;
28829
28830 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
28831 {
28832 PyThreadState* __tstate = wxPyBeginAllowThreads();
28833 result = wxTimeSpan::Hour();
28834 wxPyEndAllowThreads(__tstate);
28835 if (PyErr_Occurred()) SWIG_fail;
28836 }
28837 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28838 return resultobj;
28839 fail:
28840 return NULL;
28841 }
28842
28843
28844 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28845 PyObject *resultobj = 0;
28846 long arg1 ;
28847 wxTimeSpan result;
28848 long val1 ;
28849 int ecode1 = 0 ;
28850 PyObject * obj0 = 0 ;
28851 char * kwnames[] = {
28852 (char *) "days", NULL
28853 };
28854
28855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
28856 ecode1 = SWIG_AsVal_long(obj0, &val1);
28857 if (!SWIG_IsOK(ecode1)) {
28858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
28859 }
28860 arg1 = static_cast< long >(val1);
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 result = wxTimeSpan::Days(arg1);
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28875 PyObject *resultobj = 0;
28876 wxTimeSpan result;
28877
28878 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 result = wxTimeSpan::Day();
28882 wxPyEndAllowThreads(__tstate);
28883 if (PyErr_Occurred()) SWIG_fail;
28884 }
28885 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28886 return resultobj;
28887 fail:
28888 return NULL;
28889 }
28890
28891
28892 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28893 PyObject *resultobj = 0;
28894 long arg1 ;
28895 wxTimeSpan result;
28896 long val1 ;
28897 int ecode1 = 0 ;
28898 PyObject * obj0 = 0 ;
28899 char * kwnames[] = {
28900 (char *) "days", NULL
28901 };
28902
28903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
28904 ecode1 = SWIG_AsVal_long(obj0, &val1);
28905 if (!SWIG_IsOK(ecode1)) {
28906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
28907 }
28908 arg1 = static_cast< long >(val1);
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 result = wxTimeSpan::Weeks(arg1);
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28916 return resultobj;
28917 fail:
28918 return NULL;
28919 }
28920
28921
28922 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28923 PyObject *resultobj = 0;
28924 wxTimeSpan result;
28925
28926 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
28927 {
28928 PyThreadState* __tstate = wxPyBeginAllowThreads();
28929 result = wxTimeSpan::Week();
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28941 PyObject *resultobj = 0;
28942 long arg1 = (long) 0 ;
28943 long arg2 = (long) 0 ;
28944 long arg3 = (long) 0 ;
28945 long arg4 = (long) 0 ;
28946 wxTimeSpan *result = 0 ;
28947 long val1 ;
28948 int ecode1 = 0 ;
28949 long val2 ;
28950 int ecode2 = 0 ;
28951 long val3 ;
28952 int ecode3 = 0 ;
28953 long val4 ;
28954 int ecode4 = 0 ;
28955 PyObject * obj0 = 0 ;
28956 PyObject * obj1 = 0 ;
28957 PyObject * obj2 = 0 ;
28958 PyObject * obj3 = 0 ;
28959 char * kwnames[] = {
28960 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
28961 };
28962
28963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28964 if (obj0) {
28965 ecode1 = SWIG_AsVal_long(obj0, &val1);
28966 if (!SWIG_IsOK(ecode1)) {
28967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
28968 }
28969 arg1 = static_cast< long >(val1);
28970 }
28971 if (obj1) {
28972 ecode2 = SWIG_AsVal_long(obj1, &val2);
28973 if (!SWIG_IsOK(ecode2)) {
28974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
28975 }
28976 arg2 = static_cast< long >(val2);
28977 }
28978 if (obj2) {
28979 ecode3 = SWIG_AsVal_long(obj2, &val3);
28980 if (!SWIG_IsOK(ecode3)) {
28981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
28982 }
28983 arg3 = static_cast< long >(val3);
28984 }
28985 if (obj3) {
28986 ecode4 = SWIG_AsVal_long(obj3, &val4);
28987 if (!SWIG_IsOK(ecode4)) {
28988 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
28989 }
28990 arg4 = static_cast< long >(val4);
28991 }
28992 {
28993 PyThreadState* __tstate = wxPyBeginAllowThreads();
28994 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29006 PyObject *resultobj = 0;
29007 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29008 void *argp1 = 0 ;
29009 int res1 = 0 ;
29010 PyObject *swig_obj[1] ;
29011
29012 if (!args) SWIG_fail;
29013 swig_obj[0] = args;
29014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29015 if (!SWIG_IsOK(res1)) {
29016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29017 }
29018 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 delete arg1;
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 resultobj = SWIG_Py_Void();
29027 return resultobj;
29028 fail:
29029 return NULL;
29030 }
29031
29032
29033 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29034 PyObject *resultobj = 0;
29035 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29036 wxTimeSpan *arg2 = 0 ;
29037 wxTimeSpan *result = 0 ;
29038 void *argp1 = 0 ;
29039 int res1 = 0 ;
29040 void *argp2 = 0 ;
29041 int res2 = 0 ;
29042 PyObject * obj0 = 0 ;
29043 PyObject * obj1 = 0 ;
29044 char * kwnames[] = {
29045 (char *) "self",(char *) "diff", NULL
29046 };
29047
29048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29050 if (!SWIG_IsOK(res1)) {
29051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29052 }
29053 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29054 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29055 if (!SWIG_IsOK(res2)) {
29056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29057 }
29058 if (!argp2) {
29059 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29060 }
29061 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29062 {
29063 PyThreadState* __tstate = wxPyBeginAllowThreads();
29064 {
29065 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
29066 result = (wxTimeSpan *) &_result_ref;
29067 }
29068 wxPyEndAllowThreads(__tstate);
29069 if (PyErr_Occurred()) SWIG_fail;
29070 }
29071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29072 return resultobj;
29073 fail:
29074 return NULL;
29075 }
29076
29077
29078 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29079 PyObject *resultobj = 0;
29080 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29081 wxTimeSpan *arg2 = 0 ;
29082 wxTimeSpan *result = 0 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 void *argp2 = 0 ;
29086 int res2 = 0 ;
29087 PyObject * obj0 = 0 ;
29088 PyObject * obj1 = 0 ;
29089 char * kwnames[] = {
29090 (char *) "self",(char *) "diff", NULL
29091 };
29092
29093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29095 if (!SWIG_IsOK(res1)) {
29096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29097 }
29098 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29099 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29100 if (!SWIG_IsOK(res2)) {
29101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29102 }
29103 if (!argp2) {
29104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29105 }
29106 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 {
29110 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
29111 result = (wxTimeSpan *) &_result_ref;
29112 }
29113 wxPyEndAllowThreads(__tstate);
29114 if (PyErr_Occurred()) SWIG_fail;
29115 }
29116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29124 PyObject *resultobj = 0;
29125 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29126 int arg2 ;
29127 wxTimeSpan *result = 0 ;
29128 void *argp1 = 0 ;
29129 int res1 = 0 ;
29130 int val2 ;
29131 int ecode2 = 0 ;
29132 PyObject * obj0 = 0 ;
29133 PyObject * obj1 = 0 ;
29134 char * kwnames[] = {
29135 (char *) "self",(char *) "n", NULL
29136 };
29137
29138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29140 if (!SWIG_IsOK(res1)) {
29141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29142 }
29143 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29144 ecode2 = SWIG_AsVal_int(obj1, &val2);
29145 if (!SWIG_IsOK(ecode2)) {
29146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29147 }
29148 arg2 = static_cast< int >(val2);
29149 {
29150 PyThreadState* __tstate = wxPyBeginAllowThreads();
29151 {
29152 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
29153 result = (wxTimeSpan *) &_result_ref;
29154 }
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29166 PyObject *resultobj = 0;
29167 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29168 wxTimeSpan *result = 0 ;
29169 void *argp1 = 0 ;
29170 int res1 = 0 ;
29171 PyObject *swig_obj[1] ;
29172
29173 if (!args) SWIG_fail;
29174 swig_obj[0] = args;
29175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29176 if (!SWIG_IsOK(res1)) {
29177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29178 }
29179 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29180 {
29181 PyThreadState* __tstate = wxPyBeginAllowThreads();
29182 {
29183 wxTimeSpan &_result_ref = (arg1)->Neg();
29184 result = (wxTimeSpan *) &_result_ref;
29185 }
29186 wxPyEndAllowThreads(__tstate);
29187 if (PyErr_Occurred()) SWIG_fail;
29188 }
29189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29190 return resultobj;
29191 fail:
29192 return NULL;
29193 }
29194
29195
29196 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29197 PyObject *resultobj = 0;
29198 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29199 wxTimeSpan result;
29200 void *argp1 = 0 ;
29201 int res1 = 0 ;
29202 PyObject *swig_obj[1] ;
29203
29204 if (!args) SWIG_fail;
29205 swig_obj[0] = args;
29206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29207 if (!SWIG_IsOK(res1)) {
29208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29209 }
29210 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29211 {
29212 PyThreadState* __tstate = wxPyBeginAllowThreads();
29213 result = ((wxTimeSpan const *)arg1)->Abs();
29214 wxPyEndAllowThreads(__tstate);
29215 if (PyErr_Occurred()) SWIG_fail;
29216 }
29217 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29218 return resultobj;
29219 fail:
29220 return NULL;
29221 }
29222
29223
29224 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29225 PyObject *resultobj = 0;
29226 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29227 wxTimeSpan *arg2 = 0 ;
29228 wxTimeSpan *result = 0 ;
29229 void *argp1 = 0 ;
29230 int res1 = 0 ;
29231 void *argp2 = 0 ;
29232 int res2 = 0 ;
29233 PyObject * obj0 = 0 ;
29234 PyObject * obj1 = 0 ;
29235 char * kwnames[] = {
29236 (char *) "self",(char *) "diff", NULL
29237 };
29238
29239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29241 if (!SWIG_IsOK(res1)) {
29242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29243 }
29244 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29246 if (!SWIG_IsOK(res2)) {
29247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29248 }
29249 if (!argp2) {
29250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29251 }
29252 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 {
29256 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
29257 result = (wxTimeSpan *) &_result_ref;
29258 }
29259 wxPyEndAllowThreads(__tstate);
29260 if (PyErr_Occurred()) SWIG_fail;
29261 }
29262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29263 return resultobj;
29264 fail:
29265 return NULL;
29266 }
29267
29268
29269 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29270 PyObject *resultobj = 0;
29271 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29272 wxTimeSpan *arg2 = 0 ;
29273 wxTimeSpan *result = 0 ;
29274 void *argp1 = 0 ;
29275 int res1 = 0 ;
29276 void *argp2 = 0 ;
29277 int res2 = 0 ;
29278 PyObject * obj0 = 0 ;
29279 PyObject * obj1 = 0 ;
29280 char * kwnames[] = {
29281 (char *) "self",(char *) "diff", NULL
29282 };
29283
29284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29286 if (!SWIG_IsOK(res1)) {
29287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29288 }
29289 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29290 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29291 if (!SWIG_IsOK(res2)) {
29292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29293 }
29294 if (!argp2) {
29295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29296 }
29297 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29298 {
29299 PyThreadState* __tstate = wxPyBeginAllowThreads();
29300 {
29301 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
29302 result = (wxTimeSpan *) &_result_ref;
29303 }
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29315 PyObject *resultobj = 0;
29316 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29317 int arg2 ;
29318 wxTimeSpan *result = 0 ;
29319 void *argp1 = 0 ;
29320 int res1 = 0 ;
29321 int val2 ;
29322 int ecode2 = 0 ;
29323 PyObject * obj0 = 0 ;
29324 PyObject * obj1 = 0 ;
29325 char * kwnames[] = {
29326 (char *) "self",(char *) "n", NULL
29327 };
29328
29329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
29331 if (!SWIG_IsOK(res1)) {
29332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29333 }
29334 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29335 ecode2 = SWIG_AsVal_int(obj1, &val2);
29336 if (!SWIG_IsOK(ecode2)) {
29337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29338 }
29339 arg2 = static_cast< int >(val2);
29340 {
29341 PyThreadState* __tstate = wxPyBeginAllowThreads();
29342 {
29343 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
29344 result = (wxTimeSpan *) &_result_ref;
29345 }
29346 wxPyEndAllowThreads(__tstate);
29347 if (PyErr_Occurred()) SWIG_fail;
29348 }
29349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29357 PyObject *resultobj = 0;
29358 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29359 wxTimeSpan *result = 0 ;
29360 void *argp1 = 0 ;
29361 int res1 = 0 ;
29362 PyObject *swig_obj[1] ;
29363
29364 if (!args) SWIG_fail;
29365 swig_obj[0] = args;
29366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29367 if (!SWIG_IsOK(res1)) {
29368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29369 }
29370 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29371 {
29372 PyThreadState* __tstate = wxPyBeginAllowThreads();
29373 {
29374 wxTimeSpan &_result_ref = (arg1)->operator -();
29375 result = (wxTimeSpan *) &_result_ref;
29376 }
29377 wxPyEndAllowThreads(__tstate);
29378 if (PyErr_Occurred()) SWIG_fail;
29379 }
29380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29381 return resultobj;
29382 fail:
29383 return NULL;
29384 }
29385
29386
29387 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29388 PyObject *resultobj = 0;
29389 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29390 wxTimeSpan *arg2 = 0 ;
29391 wxTimeSpan result;
29392 void *argp1 = 0 ;
29393 int res1 = 0 ;
29394 void *argp2 = 0 ;
29395 int res2 = 0 ;
29396 PyObject * obj0 = 0 ;
29397 PyObject * obj1 = 0 ;
29398 char * kwnames[] = {
29399 (char *) "self",(char *) "other", NULL
29400 };
29401
29402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29404 if (!SWIG_IsOK(res1)) {
29405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29406 }
29407 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29408 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29409 if (!SWIG_IsOK(res2)) {
29410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29411 }
29412 if (!argp2) {
29413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29414 }
29415 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29416 {
29417 PyThreadState* __tstate = wxPyBeginAllowThreads();
29418 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
29419 wxPyEndAllowThreads(__tstate);
29420 if (PyErr_Occurred()) SWIG_fail;
29421 }
29422 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29430 PyObject *resultobj = 0;
29431 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29432 wxTimeSpan *arg2 = 0 ;
29433 wxTimeSpan result;
29434 void *argp1 = 0 ;
29435 int res1 = 0 ;
29436 void *argp2 = 0 ;
29437 int res2 = 0 ;
29438 PyObject * obj0 = 0 ;
29439 PyObject * obj1 = 0 ;
29440 char * kwnames[] = {
29441 (char *) "self",(char *) "other", NULL
29442 };
29443
29444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29446 if (!SWIG_IsOK(res1)) {
29447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29448 }
29449 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29451 if (!SWIG_IsOK(res2)) {
29452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29453 }
29454 if (!argp2) {
29455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29456 }
29457 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
29461 wxPyEndAllowThreads(__tstate);
29462 if (PyErr_Occurred()) SWIG_fail;
29463 }
29464 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29465 return resultobj;
29466 fail:
29467 return NULL;
29468 }
29469
29470
29471 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29472 PyObject *resultobj = 0;
29473 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29474 int arg2 ;
29475 wxTimeSpan result;
29476 void *argp1 = 0 ;
29477 int res1 = 0 ;
29478 int val2 ;
29479 int ecode2 = 0 ;
29480 PyObject * obj0 = 0 ;
29481 PyObject * obj1 = 0 ;
29482 char * kwnames[] = {
29483 (char *) "self",(char *) "n", NULL
29484 };
29485
29486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29488 if (!SWIG_IsOK(res1)) {
29489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29490 }
29491 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29492 ecode2 = SWIG_AsVal_int(obj1, &val2);
29493 if (!SWIG_IsOK(ecode2)) {
29494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29495 }
29496 arg2 = static_cast< int >(val2);
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 result = wxTimeSpan___mul__(arg1,arg2);
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29504 return resultobj;
29505 fail:
29506 return NULL;
29507 }
29508
29509
29510 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29511 PyObject *resultobj = 0;
29512 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29513 int arg2 ;
29514 wxTimeSpan result;
29515 void *argp1 = 0 ;
29516 int res1 = 0 ;
29517 int val2 ;
29518 int ecode2 = 0 ;
29519 PyObject * obj0 = 0 ;
29520 PyObject * obj1 = 0 ;
29521 char * kwnames[] = {
29522 (char *) "self",(char *) "n", NULL
29523 };
29524
29525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29527 if (!SWIG_IsOK(res1)) {
29528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29529 }
29530 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29531 ecode2 = SWIG_AsVal_int(obj1, &val2);
29532 if (!SWIG_IsOK(ecode2)) {
29533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29534 }
29535 arg2 = static_cast< int >(val2);
29536 {
29537 PyThreadState* __tstate = wxPyBeginAllowThreads();
29538 result = wxTimeSpan___rmul__(arg1,arg2);
29539 wxPyEndAllowThreads(__tstate);
29540 if (PyErr_Occurred()) SWIG_fail;
29541 }
29542 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
29543 return resultobj;
29544 fail:
29545 return NULL;
29546 }
29547
29548
29549 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29550 PyObject *resultobj = 0;
29551 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29552 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29553 bool result;
29554 void *argp1 = 0 ;
29555 int res1 = 0 ;
29556 void *argp2 = 0 ;
29557 int res2 = 0 ;
29558 PyObject * obj0 = 0 ;
29559 PyObject * obj1 = 0 ;
29560 char * kwnames[] = {
29561 (char *) "self",(char *) "other", NULL
29562 };
29563
29564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
29565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29566 if (!SWIG_IsOK(res1)) {
29567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29568 }
29569 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29571 if (!SWIG_IsOK(res2)) {
29572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29573 }
29574 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29575 {
29576 PyThreadState* __tstate = wxPyBeginAllowThreads();
29577 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
29578 wxPyEndAllowThreads(__tstate);
29579 if (PyErr_Occurred()) SWIG_fail;
29580 }
29581 {
29582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29583 }
29584 return resultobj;
29585 fail:
29586 return NULL;
29587 }
29588
29589
29590 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29591 PyObject *resultobj = 0;
29592 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29593 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29594 bool result;
29595 void *argp1 = 0 ;
29596 int res1 = 0 ;
29597 void *argp2 = 0 ;
29598 int res2 = 0 ;
29599 PyObject * obj0 = 0 ;
29600 PyObject * obj1 = 0 ;
29601 char * kwnames[] = {
29602 (char *) "self",(char *) "other", NULL
29603 };
29604
29605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
29606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29607 if (!SWIG_IsOK(res1)) {
29608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29609 }
29610 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29612 if (!SWIG_IsOK(res2)) {
29613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29614 }
29615 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29616 {
29617 PyThreadState* __tstate = wxPyBeginAllowThreads();
29618 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
29619 wxPyEndAllowThreads(__tstate);
29620 if (PyErr_Occurred()) SWIG_fail;
29621 }
29622 {
29623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29624 }
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj = 0;
29633 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29634 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29635 bool result;
29636 void *argp1 = 0 ;
29637 int res1 = 0 ;
29638 void *argp2 = 0 ;
29639 int res2 = 0 ;
29640 PyObject * obj0 = 0 ;
29641 PyObject * obj1 = 0 ;
29642 char * kwnames[] = {
29643 (char *) "self",(char *) "other", NULL
29644 };
29645
29646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
29647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29648 if (!SWIG_IsOK(res1)) {
29649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29650 }
29651 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29653 if (!SWIG_IsOK(res2)) {
29654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29655 }
29656 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29657 {
29658 PyThreadState* __tstate = wxPyBeginAllowThreads();
29659 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
29660 wxPyEndAllowThreads(__tstate);
29661 if (PyErr_Occurred()) SWIG_fail;
29662 }
29663 {
29664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29665 }
29666 return resultobj;
29667 fail:
29668 return NULL;
29669 }
29670
29671
29672 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29673 PyObject *resultobj = 0;
29674 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29675 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29676 bool result;
29677 void *argp1 = 0 ;
29678 int res1 = 0 ;
29679 void *argp2 = 0 ;
29680 int res2 = 0 ;
29681 PyObject * obj0 = 0 ;
29682 PyObject * obj1 = 0 ;
29683 char * kwnames[] = {
29684 (char *) "self",(char *) "other", NULL
29685 };
29686
29687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
29688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29689 if (!SWIG_IsOK(res1)) {
29690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29691 }
29692 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29693 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29694 if (!SWIG_IsOK(res2)) {
29695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29696 }
29697 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29698 {
29699 PyThreadState* __tstate = wxPyBeginAllowThreads();
29700 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
29701 wxPyEndAllowThreads(__tstate);
29702 if (PyErr_Occurred()) SWIG_fail;
29703 }
29704 {
29705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29706 }
29707 return resultobj;
29708 fail:
29709 return NULL;
29710 }
29711
29712
29713 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29714 PyObject *resultobj = 0;
29715 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29716 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29717 bool result;
29718 void *argp1 = 0 ;
29719 int res1 = 0 ;
29720 void *argp2 = 0 ;
29721 int res2 = 0 ;
29722 PyObject * obj0 = 0 ;
29723 PyObject * obj1 = 0 ;
29724 char * kwnames[] = {
29725 (char *) "self",(char *) "other", NULL
29726 };
29727
29728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29730 if (!SWIG_IsOK(res1)) {
29731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29732 }
29733 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29735 if (!SWIG_IsOK(res2)) {
29736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29737 }
29738 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29739 {
29740 PyThreadState* __tstate = wxPyBeginAllowThreads();
29741 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
29742 wxPyEndAllowThreads(__tstate);
29743 if (PyErr_Occurred()) SWIG_fail;
29744 }
29745 {
29746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29747 }
29748 return resultobj;
29749 fail:
29750 return NULL;
29751 }
29752
29753
29754 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29755 PyObject *resultobj = 0;
29756 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29757 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
29758 bool result;
29759 void *argp1 = 0 ;
29760 int res1 = 0 ;
29761 void *argp2 = 0 ;
29762 int res2 = 0 ;
29763 PyObject * obj0 = 0 ;
29764 PyObject * obj1 = 0 ;
29765 char * kwnames[] = {
29766 (char *) "self",(char *) "other", NULL
29767 };
29768
29769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
29770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29771 if (!SWIG_IsOK(res1)) {
29772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
29773 }
29774 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29775 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29776 if (!SWIG_IsOK(res2)) {
29777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
29778 }
29779 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29780 {
29781 PyThreadState* __tstate = wxPyBeginAllowThreads();
29782 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 {
29787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29788 }
29789 return resultobj;
29790 fail:
29791 return NULL;
29792 }
29793
29794
29795 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29796 PyObject *resultobj = 0;
29797 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29798 bool result;
29799 void *argp1 = 0 ;
29800 int res1 = 0 ;
29801 PyObject *swig_obj[1] ;
29802
29803 if (!args) SWIG_fail;
29804 swig_obj[0] = args;
29805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29806 if (!SWIG_IsOK(res1)) {
29807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29808 }
29809 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29810 {
29811 PyThreadState* __tstate = wxPyBeginAllowThreads();
29812 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
29813 wxPyEndAllowThreads(__tstate);
29814 if (PyErr_Occurred()) SWIG_fail;
29815 }
29816 {
29817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29818 }
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29826 PyObject *resultobj = 0;
29827 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29828 bool result;
29829 void *argp1 = 0 ;
29830 int res1 = 0 ;
29831 PyObject *swig_obj[1] ;
29832
29833 if (!args) SWIG_fail;
29834 swig_obj[0] = args;
29835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29836 if (!SWIG_IsOK(res1)) {
29837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29838 }
29839 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29840 {
29841 PyThreadState* __tstate = wxPyBeginAllowThreads();
29842 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
29843 wxPyEndAllowThreads(__tstate);
29844 if (PyErr_Occurred()) SWIG_fail;
29845 }
29846 {
29847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29848 }
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29856 PyObject *resultobj = 0;
29857 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29858 bool result;
29859 void *argp1 = 0 ;
29860 int res1 = 0 ;
29861 PyObject *swig_obj[1] ;
29862
29863 if (!args) SWIG_fail;
29864 swig_obj[0] = args;
29865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29866 if (!SWIG_IsOK(res1)) {
29867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29868 }
29869 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29870 {
29871 PyThreadState* __tstate = wxPyBeginAllowThreads();
29872 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 {
29877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29878 }
29879 return resultobj;
29880 fail:
29881 return NULL;
29882 }
29883
29884
29885 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29886 PyObject *resultobj = 0;
29887 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29888 wxTimeSpan *arg2 = 0 ;
29889 bool result;
29890 void *argp1 = 0 ;
29891 int res1 = 0 ;
29892 void *argp2 = 0 ;
29893 int res2 = 0 ;
29894 PyObject * obj0 = 0 ;
29895 PyObject * obj1 = 0 ;
29896 char * kwnames[] = {
29897 (char *) "self",(char *) "ts", NULL
29898 };
29899
29900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
29901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29904 }
29905 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29906 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29907 if (!SWIG_IsOK(res2)) {
29908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29909 }
29910 if (!argp2) {
29911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29912 }
29913 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 {
29921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29922 }
29923 return resultobj;
29924 fail:
29925 return NULL;
29926 }
29927
29928
29929 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29930 PyObject *resultobj = 0;
29931 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29932 wxTimeSpan *arg2 = 0 ;
29933 bool result;
29934 void *argp1 = 0 ;
29935 int res1 = 0 ;
29936 void *argp2 = 0 ;
29937 int res2 = 0 ;
29938 PyObject * obj0 = 0 ;
29939 PyObject * obj1 = 0 ;
29940 char * kwnames[] = {
29941 (char *) "self",(char *) "ts", NULL
29942 };
29943
29944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
29945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29946 if (!SWIG_IsOK(res1)) {
29947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29948 }
29949 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29950 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29951 if (!SWIG_IsOK(res2)) {
29952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29953 }
29954 if (!argp2) {
29955 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29956 }
29957 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
29958 {
29959 PyThreadState* __tstate = wxPyBeginAllowThreads();
29960 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
29961 wxPyEndAllowThreads(__tstate);
29962 if (PyErr_Occurred()) SWIG_fail;
29963 }
29964 {
29965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29966 }
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29974 PyObject *resultobj = 0;
29975 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29976 wxTimeSpan *arg2 = 0 ;
29977 bool result;
29978 void *argp1 = 0 ;
29979 int res1 = 0 ;
29980 void *argp2 = 0 ;
29981 int res2 = 0 ;
29982 PyObject * obj0 = 0 ;
29983 PyObject * obj1 = 0 ;
29984 char * kwnames[] = {
29985 (char *) "self",(char *) "t", NULL
29986 };
29987
29988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
29989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29990 if (!SWIG_IsOK(res1)) {
29991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29992 }
29993 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29994 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
29995 if (!SWIG_IsOK(res2)) {
29996 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
29997 }
29998 if (!argp2) {
29999 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
30000 }
30001 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
30005 wxPyEndAllowThreads(__tstate);
30006 if (PyErr_Occurred()) SWIG_fail;
30007 }
30008 {
30009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30010 }
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30018 PyObject *resultobj = 0;
30019 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30020 int result;
30021 void *argp1 = 0 ;
30022 int res1 = 0 ;
30023 PyObject *swig_obj[1] ;
30024
30025 if (!args) SWIG_fail;
30026 swig_obj[0] = args;
30027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30028 if (!SWIG_IsOK(res1)) {
30029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30030 }
30031 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30032 {
30033 PyThreadState* __tstate = wxPyBeginAllowThreads();
30034 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
30035 wxPyEndAllowThreads(__tstate);
30036 if (PyErr_Occurred()) SWIG_fail;
30037 }
30038 resultobj = SWIG_From_int(static_cast< int >(result));
30039 return resultobj;
30040 fail:
30041 return NULL;
30042 }
30043
30044
30045 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30046 PyObject *resultobj = 0;
30047 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30048 int result;
30049 void *argp1 = 0 ;
30050 int res1 = 0 ;
30051 PyObject *swig_obj[1] ;
30052
30053 if (!args) SWIG_fail;
30054 swig_obj[0] = args;
30055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30056 if (!SWIG_IsOK(res1)) {
30057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30058 }
30059 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30060 {
30061 PyThreadState* __tstate = wxPyBeginAllowThreads();
30062 result = (int)((wxTimeSpan const *)arg1)->GetDays();
30063 wxPyEndAllowThreads(__tstate);
30064 if (PyErr_Occurred()) SWIG_fail;
30065 }
30066 resultobj = SWIG_From_int(static_cast< int >(result));
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30074 PyObject *resultobj = 0;
30075 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30076 int result;
30077 void *argp1 = 0 ;
30078 int res1 = 0 ;
30079 PyObject *swig_obj[1] ;
30080
30081 if (!args) SWIG_fail;
30082 swig_obj[0] = args;
30083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30084 if (!SWIG_IsOK(res1)) {
30085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30086 }
30087 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30088 {
30089 PyThreadState* __tstate = wxPyBeginAllowThreads();
30090 result = (int)((wxTimeSpan const *)arg1)->GetHours();
30091 wxPyEndAllowThreads(__tstate);
30092 if (PyErr_Occurred()) SWIG_fail;
30093 }
30094 resultobj = SWIG_From_int(static_cast< int >(result));
30095 return resultobj;
30096 fail:
30097 return NULL;
30098 }
30099
30100
30101 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30102 PyObject *resultobj = 0;
30103 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30104 int result;
30105 void *argp1 = 0 ;
30106 int res1 = 0 ;
30107 PyObject *swig_obj[1] ;
30108
30109 if (!args) SWIG_fail;
30110 swig_obj[0] = args;
30111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30112 if (!SWIG_IsOK(res1)) {
30113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30114 }
30115 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30116 {
30117 PyThreadState* __tstate = wxPyBeginAllowThreads();
30118 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 resultobj = SWIG_From_int(static_cast< int >(result));
30123 return resultobj;
30124 fail:
30125 return NULL;
30126 }
30127
30128
30129 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30130 PyObject *resultobj = 0;
30131 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30132 wxLongLong result;
30133 void *argp1 = 0 ;
30134 int res1 = 0 ;
30135 PyObject *swig_obj[1] ;
30136
30137 if (!args) SWIG_fail;
30138 swig_obj[0] = args;
30139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30140 if (!SWIG_IsOK(res1)) {
30141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30142 }
30143 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30144 {
30145 PyThreadState* __tstate = wxPyBeginAllowThreads();
30146 result = ((wxTimeSpan const *)arg1)->GetSeconds();
30147 wxPyEndAllowThreads(__tstate);
30148 if (PyErr_Occurred()) SWIG_fail;
30149 }
30150 {
30151 PyObject *hi, *lo, *shifter, *shifted;
30152 hi = PyLong_FromLong( (&result)->GetHi() );
30153 lo = PyLong_FromLong( (&result)->GetLo() );
30154 shifter = PyLong_FromLong(32);
30155 shifted = PyNumber_Lshift(hi, shifter);
30156 resultobj = PyNumber_Or(shifted, lo);
30157 Py_DECREF(hi);
30158 Py_DECREF(lo);
30159 Py_DECREF(shifter);
30160 Py_DECREF(shifted);
30161 }
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30169 PyObject *resultobj = 0;
30170 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30171 wxLongLong result;
30172 void *argp1 = 0 ;
30173 int res1 = 0 ;
30174 PyObject *swig_obj[1] ;
30175
30176 if (!args) SWIG_fail;
30177 swig_obj[0] = args;
30178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30179 if (!SWIG_IsOK(res1)) {
30180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30181 }
30182 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30183 {
30184 PyThreadState* __tstate = wxPyBeginAllowThreads();
30185 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
30186 wxPyEndAllowThreads(__tstate);
30187 if (PyErr_Occurred()) SWIG_fail;
30188 }
30189 {
30190 PyObject *hi, *lo, *shifter, *shifted;
30191 hi = PyLong_FromLong( (&result)->GetHi() );
30192 lo = PyLong_FromLong( (&result)->GetLo() );
30193 shifter = PyLong_FromLong(32);
30194 shifted = PyNumber_Lshift(hi, shifter);
30195 resultobj = PyNumber_Or(shifted, lo);
30196 Py_DECREF(hi);
30197 Py_DECREF(lo);
30198 Py_DECREF(shifter);
30199 Py_DECREF(shifted);
30200 }
30201 return resultobj;
30202 fail:
30203 return NULL;
30204 }
30205
30206
30207 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30208 PyObject *resultobj = 0;
30209 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
30210 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
30211 wxString *arg2 = (wxString *) &arg2_defvalue ;
30212 wxString result;
30213 void *argp1 = 0 ;
30214 int res1 = 0 ;
30215 bool temp2 = false ;
30216 PyObject * obj0 = 0 ;
30217 PyObject * obj1 = 0 ;
30218 char * kwnames[] = {
30219 (char *) "self",(char *) "format", NULL
30220 };
30221
30222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
30223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
30224 if (!SWIG_IsOK(res1)) {
30225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
30226 }
30227 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
30228 if (obj1) {
30229 {
30230 arg2 = wxString_in_helper(obj1);
30231 if (arg2 == NULL) SWIG_fail;
30232 temp2 = true;
30233 }
30234 }
30235 {
30236 PyThreadState* __tstate = wxPyBeginAllowThreads();
30237 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
30238 wxPyEndAllowThreads(__tstate);
30239 if (PyErr_Occurred()) SWIG_fail;
30240 }
30241 {
30242 #if wxUSE_UNICODE
30243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30244 #else
30245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30246 #endif
30247 }
30248 {
30249 if (temp2)
30250 delete arg2;
30251 }
30252 return resultobj;
30253 fail:
30254 {
30255 if (temp2)
30256 delete arg2;
30257 }
30258 return NULL;
30259 }
30260
30261
30262 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30263 PyObject *obj;
30264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30265 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
30266 return SWIG_Py_Void();
30267 }
30268
30269 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30270 return SWIG_Python_InitShadowInstance(args);
30271 }
30272
30273 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30274 PyObject *resultobj = 0;
30275 int arg1 = (int) 0 ;
30276 int arg2 = (int) 0 ;
30277 int arg3 = (int) 0 ;
30278 int arg4 = (int) 0 ;
30279 wxDateSpan *result = 0 ;
30280 int val1 ;
30281 int ecode1 = 0 ;
30282 int val2 ;
30283 int ecode2 = 0 ;
30284 int val3 ;
30285 int ecode3 = 0 ;
30286 int val4 ;
30287 int ecode4 = 0 ;
30288 PyObject * obj0 = 0 ;
30289 PyObject * obj1 = 0 ;
30290 PyObject * obj2 = 0 ;
30291 PyObject * obj3 = 0 ;
30292 char * kwnames[] = {
30293 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
30294 };
30295
30296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30297 if (obj0) {
30298 ecode1 = SWIG_AsVal_int(obj0, &val1);
30299 if (!SWIG_IsOK(ecode1)) {
30300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
30301 }
30302 arg1 = static_cast< int >(val1);
30303 }
30304 if (obj1) {
30305 ecode2 = SWIG_AsVal_int(obj1, &val2);
30306 if (!SWIG_IsOK(ecode2)) {
30307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
30308 }
30309 arg2 = static_cast< int >(val2);
30310 }
30311 if (obj2) {
30312 ecode3 = SWIG_AsVal_int(obj2, &val3);
30313 if (!SWIG_IsOK(ecode3)) {
30314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
30315 }
30316 arg3 = static_cast< int >(val3);
30317 }
30318 if (obj3) {
30319 ecode4 = SWIG_AsVal_int(obj3, &val4);
30320 if (!SWIG_IsOK(ecode4)) {
30321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
30322 }
30323 arg4 = static_cast< int >(val4);
30324 }
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
30328 wxPyEndAllowThreads(__tstate);
30329 if (PyErr_Occurred()) SWIG_fail;
30330 }
30331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30339 PyObject *resultobj = 0;
30340 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30341 void *argp1 = 0 ;
30342 int res1 = 0 ;
30343 PyObject *swig_obj[1] ;
30344
30345 if (!args) SWIG_fail;
30346 swig_obj[0] = args;
30347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30348 if (!SWIG_IsOK(res1)) {
30349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30350 }
30351 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 delete arg1;
30355
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 resultobj = SWIG_Py_Void();
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30367 PyObject *resultobj = 0;
30368 int arg1 ;
30369 wxDateSpan result;
30370 int val1 ;
30371 int ecode1 = 0 ;
30372 PyObject * obj0 = 0 ;
30373 char * kwnames[] = {
30374 (char *) "days", NULL
30375 };
30376
30377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
30378 ecode1 = SWIG_AsVal_int(obj0, &val1);
30379 if (!SWIG_IsOK(ecode1)) {
30380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
30381 }
30382 arg1 = static_cast< int >(val1);
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 result = wxDateSpan::Days(arg1);
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30397 PyObject *resultobj = 0;
30398 wxDateSpan result;
30399
30400 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
30401 {
30402 PyThreadState* __tstate = wxPyBeginAllowThreads();
30403 result = wxDateSpan::Day();
30404 wxPyEndAllowThreads(__tstate);
30405 if (PyErr_Occurred()) SWIG_fail;
30406 }
30407 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30408 return resultobj;
30409 fail:
30410 return NULL;
30411 }
30412
30413
30414 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30415 PyObject *resultobj = 0;
30416 int arg1 ;
30417 wxDateSpan result;
30418 int val1 ;
30419 int ecode1 = 0 ;
30420 PyObject * obj0 = 0 ;
30421 char * kwnames[] = {
30422 (char *) "weeks", NULL
30423 };
30424
30425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
30426 ecode1 = SWIG_AsVal_int(obj0, &val1);
30427 if (!SWIG_IsOK(ecode1)) {
30428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
30429 }
30430 arg1 = static_cast< int >(val1);
30431 {
30432 PyThreadState* __tstate = wxPyBeginAllowThreads();
30433 result = wxDateSpan::Weeks(arg1);
30434 wxPyEndAllowThreads(__tstate);
30435 if (PyErr_Occurred()) SWIG_fail;
30436 }
30437 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30438 return resultobj;
30439 fail:
30440 return NULL;
30441 }
30442
30443
30444 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30445 PyObject *resultobj = 0;
30446 wxDateSpan result;
30447
30448 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
30449 {
30450 PyThreadState* __tstate = wxPyBeginAllowThreads();
30451 result = wxDateSpan::Week();
30452 wxPyEndAllowThreads(__tstate);
30453 if (PyErr_Occurred()) SWIG_fail;
30454 }
30455 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30456 return resultobj;
30457 fail:
30458 return NULL;
30459 }
30460
30461
30462 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30463 PyObject *resultobj = 0;
30464 int arg1 ;
30465 wxDateSpan result;
30466 int val1 ;
30467 int ecode1 = 0 ;
30468 PyObject * obj0 = 0 ;
30469 char * kwnames[] = {
30470 (char *) "mon", NULL
30471 };
30472
30473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
30474 ecode1 = SWIG_AsVal_int(obj0, &val1);
30475 if (!SWIG_IsOK(ecode1)) {
30476 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
30477 }
30478 arg1 = static_cast< int >(val1);
30479 {
30480 PyThreadState* __tstate = wxPyBeginAllowThreads();
30481 result = wxDateSpan::Months(arg1);
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30493 PyObject *resultobj = 0;
30494 wxDateSpan result;
30495
30496 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 result = wxDateSpan::Month();
30500 wxPyEndAllowThreads(__tstate);
30501 if (PyErr_Occurred()) SWIG_fail;
30502 }
30503 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30504 return resultobj;
30505 fail:
30506 return NULL;
30507 }
30508
30509
30510 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30511 PyObject *resultobj = 0;
30512 int arg1 ;
30513 wxDateSpan result;
30514 int val1 ;
30515 int ecode1 = 0 ;
30516 PyObject * obj0 = 0 ;
30517 char * kwnames[] = {
30518 (char *) "years", NULL
30519 };
30520
30521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
30522 ecode1 = SWIG_AsVal_int(obj0, &val1);
30523 if (!SWIG_IsOK(ecode1)) {
30524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
30525 }
30526 arg1 = static_cast< int >(val1);
30527 {
30528 PyThreadState* __tstate = wxPyBeginAllowThreads();
30529 result = wxDateSpan::Years(arg1);
30530 wxPyEndAllowThreads(__tstate);
30531 if (PyErr_Occurred()) SWIG_fail;
30532 }
30533 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30534 return resultobj;
30535 fail:
30536 return NULL;
30537 }
30538
30539
30540 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30541 PyObject *resultobj = 0;
30542 wxDateSpan result;
30543
30544 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
30545 {
30546 PyThreadState* __tstate = wxPyBeginAllowThreads();
30547 result = wxDateSpan::Year();
30548 wxPyEndAllowThreads(__tstate);
30549 if (PyErr_Occurred()) SWIG_fail;
30550 }
30551 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30552 return resultobj;
30553 fail:
30554 return NULL;
30555 }
30556
30557
30558 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30559 PyObject *resultobj = 0;
30560 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30561 int arg2 ;
30562 wxDateSpan *result = 0 ;
30563 void *argp1 = 0 ;
30564 int res1 = 0 ;
30565 int val2 ;
30566 int ecode2 = 0 ;
30567 PyObject * obj0 = 0 ;
30568 PyObject * obj1 = 0 ;
30569 char * kwnames[] = {
30570 (char *) "self",(char *) "n", NULL
30571 };
30572
30573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
30574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30575 if (!SWIG_IsOK(res1)) {
30576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30577 }
30578 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30579 ecode2 = SWIG_AsVal_int(obj1, &val2);
30580 if (!SWIG_IsOK(ecode2)) {
30581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
30582 }
30583 arg2 = static_cast< int >(val2);
30584 {
30585 PyThreadState* __tstate = wxPyBeginAllowThreads();
30586 {
30587 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
30588 result = (wxDateSpan *) &_result_ref;
30589 }
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30594 return resultobj;
30595 fail:
30596 return NULL;
30597 }
30598
30599
30600 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30601 PyObject *resultobj = 0;
30602 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30603 int arg2 ;
30604 wxDateSpan *result = 0 ;
30605 void *argp1 = 0 ;
30606 int res1 = 0 ;
30607 int val2 ;
30608 int ecode2 = 0 ;
30609 PyObject * obj0 = 0 ;
30610 PyObject * obj1 = 0 ;
30611 char * kwnames[] = {
30612 (char *) "self",(char *) "n", NULL
30613 };
30614
30615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
30616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30617 if (!SWIG_IsOK(res1)) {
30618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30619 }
30620 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30621 ecode2 = SWIG_AsVal_int(obj1, &val2);
30622 if (!SWIG_IsOK(ecode2)) {
30623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
30624 }
30625 arg2 = static_cast< int >(val2);
30626 {
30627 PyThreadState* __tstate = wxPyBeginAllowThreads();
30628 {
30629 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
30630 result = (wxDateSpan *) &_result_ref;
30631 }
30632 wxPyEndAllowThreads(__tstate);
30633 if (PyErr_Occurred()) SWIG_fail;
30634 }
30635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30643 PyObject *resultobj = 0;
30644 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30645 int arg2 ;
30646 wxDateSpan *result = 0 ;
30647 void *argp1 = 0 ;
30648 int res1 = 0 ;
30649 int val2 ;
30650 int ecode2 = 0 ;
30651 PyObject * obj0 = 0 ;
30652 PyObject * obj1 = 0 ;
30653 char * kwnames[] = {
30654 (char *) "self",(char *) "n", NULL
30655 };
30656
30657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
30658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30659 if (!SWIG_IsOK(res1)) {
30660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30661 }
30662 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30663 ecode2 = SWIG_AsVal_int(obj1, &val2);
30664 if (!SWIG_IsOK(ecode2)) {
30665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
30666 }
30667 arg2 = static_cast< int >(val2);
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 {
30671 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
30672 result = (wxDateSpan *) &_result_ref;
30673 }
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30685 PyObject *resultobj = 0;
30686 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30687 int arg2 ;
30688 wxDateSpan *result = 0 ;
30689 void *argp1 = 0 ;
30690 int res1 = 0 ;
30691 int val2 ;
30692 int ecode2 = 0 ;
30693 PyObject * obj0 = 0 ;
30694 PyObject * obj1 = 0 ;
30695 char * kwnames[] = {
30696 (char *) "self",(char *) "n", NULL
30697 };
30698
30699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
30700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30701 if (!SWIG_IsOK(res1)) {
30702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30703 }
30704 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30705 ecode2 = SWIG_AsVal_int(obj1, &val2);
30706 if (!SWIG_IsOK(ecode2)) {
30707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
30708 }
30709 arg2 = static_cast< int >(val2);
30710 {
30711 PyThreadState* __tstate = wxPyBeginAllowThreads();
30712 {
30713 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
30714 result = (wxDateSpan *) &_result_ref;
30715 }
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30720 return resultobj;
30721 fail:
30722 return NULL;
30723 }
30724
30725
30726 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30727 PyObject *resultobj = 0;
30728 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30729 int result;
30730 void *argp1 = 0 ;
30731 int res1 = 0 ;
30732 PyObject *swig_obj[1] ;
30733
30734 if (!args) SWIG_fail;
30735 swig_obj[0] = args;
30736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30737 if (!SWIG_IsOK(res1)) {
30738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30739 }
30740 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30741 {
30742 PyThreadState* __tstate = wxPyBeginAllowThreads();
30743 result = (int)((wxDateSpan const *)arg1)->GetYears();
30744 wxPyEndAllowThreads(__tstate);
30745 if (PyErr_Occurred()) SWIG_fail;
30746 }
30747 resultobj = SWIG_From_int(static_cast< int >(result));
30748 return resultobj;
30749 fail:
30750 return NULL;
30751 }
30752
30753
30754 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30755 PyObject *resultobj = 0;
30756 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30757 int result;
30758 void *argp1 = 0 ;
30759 int res1 = 0 ;
30760 PyObject *swig_obj[1] ;
30761
30762 if (!args) SWIG_fail;
30763 swig_obj[0] = args;
30764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30765 if (!SWIG_IsOK(res1)) {
30766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30767 }
30768 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30769 {
30770 PyThreadState* __tstate = wxPyBeginAllowThreads();
30771 result = (int)((wxDateSpan const *)arg1)->GetMonths();
30772 wxPyEndAllowThreads(__tstate);
30773 if (PyErr_Occurred()) SWIG_fail;
30774 }
30775 resultobj = SWIG_From_int(static_cast< int >(result));
30776 return resultobj;
30777 fail:
30778 return NULL;
30779 }
30780
30781
30782 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30783 PyObject *resultobj = 0;
30784 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30785 int result;
30786 void *argp1 = 0 ;
30787 int res1 = 0 ;
30788 PyObject *swig_obj[1] ;
30789
30790 if (!args) SWIG_fail;
30791 swig_obj[0] = args;
30792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30793 if (!SWIG_IsOK(res1)) {
30794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30795 }
30796 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30797 {
30798 PyThreadState* __tstate = wxPyBeginAllowThreads();
30799 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
30800 wxPyEndAllowThreads(__tstate);
30801 if (PyErr_Occurred()) SWIG_fail;
30802 }
30803 resultobj = SWIG_From_int(static_cast< int >(result));
30804 return resultobj;
30805 fail:
30806 return NULL;
30807 }
30808
30809
30810 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30811 PyObject *resultobj = 0;
30812 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30813 int result;
30814 void *argp1 = 0 ;
30815 int res1 = 0 ;
30816 PyObject *swig_obj[1] ;
30817
30818 if (!args) SWIG_fail;
30819 swig_obj[0] = args;
30820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30821 if (!SWIG_IsOK(res1)) {
30822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30823 }
30824 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30825 {
30826 PyThreadState* __tstate = wxPyBeginAllowThreads();
30827 result = (int)((wxDateSpan const *)arg1)->GetDays();
30828 wxPyEndAllowThreads(__tstate);
30829 if (PyErr_Occurred()) SWIG_fail;
30830 }
30831 resultobj = SWIG_From_int(static_cast< int >(result));
30832 return resultobj;
30833 fail:
30834 return NULL;
30835 }
30836
30837
30838 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30839 PyObject *resultobj = 0;
30840 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30841 int result;
30842 void *argp1 = 0 ;
30843 int res1 = 0 ;
30844 PyObject *swig_obj[1] ;
30845
30846 if (!args) SWIG_fail;
30847 swig_obj[0] = args;
30848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30849 if (!SWIG_IsOK(res1)) {
30850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
30851 }
30852 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30853 {
30854 PyThreadState* __tstate = wxPyBeginAllowThreads();
30855 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
30856 wxPyEndAllowThreads(__tstate);
30857 if (PyErr_Occurred()) SWIG_fail;
30858 }
30859 resultobj = SWIG_From_int(static_cast< int >(result));
30860 return resultobj;
30861 fail:
30862 return NULL;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30867 PyObject *resultobj = 0;
30868 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30869 wxDateSpan *arg2 = 0 ;
30870 wxDateSpan *result = 0 ;
30871 void *argp1 = 0 ;
30872 int res1 = 0 ;
30873 void *argp2 = 0 ;
30874 int res2 = 0 ;
30875 PyObject * obj0 = 0 ;
30876 PyObject * obj1 = 0 ;
30877 char * kwnames[] = {
30878 (char *) "self",(char *) "other", NULL
30879 };
30880
30881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
30882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30883 if (!SWIG_IsOK(res1)) {
30884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30885 }
30886 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30887 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30888 if (!SWIG_IsOK(res2)) {
30889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30890 }
30891 if (!argp2) {
30892 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30893 }
30894 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30895 {
30896 PyThreadState* __tstate = wxPyBeginAllowThreads();
30897 {
30898 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
30899 result = (wxDateSpan *) &_result_ref;
30900 }
30901 wxPyEndAllowThreads(__tstate);
30902 if (PyErr_Occurred()) SWIG_fail;
30903 }
30904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30905 return resultobj;
30906 fail:
30907 return NULL;
30908 }
30909
30910
30911 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30912 PyObject *resultobj = 0;
30913 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30914 wxDateSpan *arg2 = 0 ;
30915 wxDateSpan *result = 0 ;
30916 void *argp1 = 0 ;
30917 int res1 = 0 ;
30918 void *argp2 = 0 ;
30919 int res2 = 0 ;
30920 PyObject * obj0 = 0 ;
30921 PyObject * obj1 = 0 ;
30922 char * kwnames[] = {
30923 (char *) "self",(char *) "other", NULL
30924 };
30925
30926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
30927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30928 if (!SWIG_IsOK(res1)) {
30929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30930 }
30931 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30932 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30933 if (!SWIG_IsOK(res2)) {
30934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30935 }
30936 if (!argp2) {
30937 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30938 }
30939 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 {
30943 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
30944 result = (wxDateSpan *) &_result_ref;
30945 }
30946 wxPyEndAllowThreads(__tstate);
30947 if (PyErr_Occurred()) SWIG_fail;
30948 }
30949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30957 PyObject *resultobj = 0;
30958 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30959 wxDateSpan *result = 0 ;
30960 void *argp1 = 0 ;
30961 int res1 = 0 ;
30962 PyObject *swig_obj[1] ;
30963
30964 if (!args) SWIG_fail;
30965 swig_obj[0] = args;
30966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30967 if (!SWIG_IsOK(res1)) {
30968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30969 }
30970 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30971 {
30972 PyThreadState* __tstate = wxPyBeginAllowThreads();
30973 {
30974 wxDateSpan &_result_ref = (arg1)->Neg();
30975 result = (wxDateSpan *) &_result_ref;
30976 }
30977 wxPyEndAllowThreads(__tstate);
30978 if (PyErr_Occurred()) SWIG_fail;
30979 }
30980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
30981 return resultobj;
30982 fail:
30983 return NULL;
30984 }
30985
30986
30987 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30988 PyObject *resultobj = 0;
30989 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30990 int arg2 ;
30991 wxDateSpan *result = 0 ;
30992 void *argp1 = 0 ;
30993 int res1 = 0 ;
30994 int val2 ;
30995 int ecode2 = 0 ;
30996 PyObject * obj0 = 0 ;
30997 PyObject * obj1 = 0 ;
30998 char * kwnames[] = {
30999 (char *) "self",(char *) "factor", NULL
31000 };
31001
31002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
31003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31004 if (!SWIG_IsOK(res1)) {
31005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31006 }
31007 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31008 ecode2 = SWIG_AsVal_int(obj1, &val2);
31009 if (!SWIG_IsOK(ecode2)) {
31010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
31011 }
31012 arg2 = static_cast< int >(val2);
31013 {
31014 PyThreadState* __tstate = wxPyBeginAllowThreads();
31015 {
31016 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
31017 result = (wxDateSpan *) &_result_ref;
31018 }
31019 wxPyEndAllowThreads(__tstate);
31020 if (PyErr_Occurred()) SWIG_fail;
31021 }
31022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31030 PyObject *resultobj = 0;
31031 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31032 wxDateSpan *arg2 = 0 ;
31033 wxDateSpan *result = 0 ;
31034 void *argp1 = 0 ;
31035 int res1 = 0 ;
31036 void *argp2 = 0 ;
31037 int res2 = 0 ;
31038 PyObject * obj0 = 0 ;
31039 PyObject * obj1 = 0 ;
31040 char * kwnames[] = {
31041 (char *) "self",(char *) "other", NULL
31042 };
31043
31044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
31045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31046 if (!SWIG_IsOK(res1)) {
31047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31048 }
31049 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31050 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31051 if (!SWIG_IsOK(res2)) {
31052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31053 }
31054 if (!argp2) {
31055 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31056 }
31057 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 {
31061 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
31062 result = (wxDateSpan *) &_result_ref;
31063 }
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31068 return resultobj;
31069 fail:
31070 return NULL;
31071 }
31072
31073
31074 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31075 PyObject *resultobj = 0;
31076 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31077 wxDateSpan *arg2 = 0 ;
31078 wxDateSpan *result = 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 void *argp2 = 0 ;
31082 int res2 = 0 ;
31083 PyObject * obj0 = 0 ;
31084 PyObject * obj1 = 0 ;
31085 char * kwnames[] = {
31086 (char *) "self",(char *) "other", NULL
31087 };
31088
31089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
31090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31091 if (!SWIG_IsOK(res1)) {
31092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31093 }
31094 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31096 if (!SWIG_IsOK(res2)) {
31097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31098 }
31099 if (!argp2) {
31100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31101 }
31102 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31103 {
31104 PyThreadState* __tstate = wxPyBeginAllowThreads();
31105 {
31106 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
31107 result = (wxDateSpan *) &_result_ref;
31108 }
31109 wxPyEndAllowThreads(__tstate);
31110 if (PyErr_Occurred()) SWIG_fail;
31111 }
31112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31113 return resultobj;
31114 fail:
31115 return NULL;
31116 }
31117
31118
31119 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31120 PyObject *resultobj = 0;
31121 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31122 wxDateSpan *result = 0 ;
31123 void *argp1 = 0 ;
31124 int res1 = 0 ;
31125 PyObject *swig_obj[1] ;
31126
31127 if (!args) SWIG_fail;
31128 swig_obj[0] = args;
31129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31130 if (!SWIG_IsOK(res1)) {
31131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31132 }
31133 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 {
31137 wxDateSpan &_result_ref = (arg1)->operator -();
31138 result = (wxDateSpan *) &_result_ref;
31139 }
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31151 PyObject *resultobj = 0;
31152 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31153 int arg2 ;
31154 wxDateSpan *result = 0 ;
31155 void *argp1 = 0 ;
31156 int res1 = 0 ;
31157 int val2 ;
31158 int ecode2 = 0 ;
31159 PyObject * obj0 = 0 ;
31160 PyObject * obj1 = 0 ;
31161 char * kwnames[] = {
31162 (char *) "self",(char *) "factor", NULL
31163 };
31164
31165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
31166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
31167 if (!SWIG_IsOK(res1)) {
31168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31169 }
31170 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31171 ecode2 = SWIG_AsVal_int(obj1, &val2);
31172 if (!SWIG_IsOK(ecode2)) {
31173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
31174 }
31175 arg2 = static_cast< int >(val2);
31176 {
31177 PyThreadState* __tstate = wxPyBeginAllowThreads();
31178 {
31179 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
31180 result = (wxDateSpan *) &_result_ref;
31181 }
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31193 PyObject *resultobj = 0;
31194 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31195 wxDateSpan *arg2 = 0 ;
31196 wxDateSpan result;
31197 void *argp1 = 0 ;
31198 int res1 = 0 ;
31199 void *argp2 = 0 ;
31200 int res2 = 0 ;
31201 PyObject * obj0 = 0 ;
31202 PyObject * obj1 = 0 ;
31203 char * kwnames[] = {
31204 (char *) "self",(char *) "other", NULL
31205 };
31206
31207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
31208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31209 if (!SWIG_IsOK(res1)) {
31210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31211 }
31212 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31213 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31214 if (!SWIG_IsOK(res2)) {
31215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31216 }
31217 if (!argp2) {
31218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31219 }
31220 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31228 return resultobj;
31229 fail:
31230 return NULL;
31231 }
31232
31233
31234 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31235 PyObject *resultobj = 0;
31236 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31237 wxDateSpan *arg2 = 0 ;
31238 wxDateSpan result;
31239 void *argp1 = 0 ;
31240 int res1 = 0 ;
31241 void *argp2 = 0 ;
31242 int res2 = 0 ;
31243 PyObject * obj0 = 0 ;
31244 PyObject * obj1 = 0 ;
31245 char * kwnames[] = {
31246 (char *) "self",(char *) "other", NULL
31247 };
31248
31249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
31250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31251 if (!SWIG_IsOK(res1)) {
31252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31253 }
31254 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31255 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
31256 if (!SWIG_IsOK(res2)) {
31257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31258 }
31259 if (!argp2) {
31260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
31261 }
31262 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31263 {
31264 PyThreadState* __tstate = wxPyBeginAllowThreads();
31265 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31277 PyObject *resultobj = 0;
31278 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31279 int arg2 ;
31280 wxDateSpan result;
31281 void *argp1 = 0 ;
31282 int res1 = 0 ;
31283 int val2 ;
31284 int ecode2 = 0 ;
31285 PyObject * obj0 = 0 ;
31286 PyObject * obj1 = 0 ;
31287 char * kwnames[] = {
31288 (char *) "self",(char *) "n", NULL
31289 };
31290
31291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
31292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31293 if (!SWIG_IsOK(res1)) {
31294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31295 }
31296 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31297 ecode2 = SWIG_AsVal_int(obj1, &val2);
31298 if (!SWIG_IsOK(ecode2)) {
31299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
31300 }
31301 arg2 = static_cast< int >(val2);
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 result = wxDateSpan___mul__(arg1,arg2);
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj = 0;
31317 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31318 int arg2 ;
31319 wxDateSpan result;
31320 void *argp1 = 0 ;
31321 int res1 = 0 ;
31322 int val2 ;
31323 int ecode2 = 0 ;
31324 PyObject * obj0 = 0 ;
31325 PyObject * obj1 = 0 ;
31326 char * kwnames[] = {
31327 (char *) "self",(char *) "n", NULL
31328 };
31329
31330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
31331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31332 if (!SWIG_IsOK(res1)) {
31333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31334 }
31335 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31336 ecode2 = SWIG_AsVal_int(obj1, &val2);
31337 if (!SWIG_IsOK(ecode2)) {
31338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
31339 }
31340 arg2 = static_cast< int >(val2);
31341 {
31342 PyThreadState* __tstate = wxPyBeginAllowThreads();
31343 result = wxDateSpan___rmul__(arg1,arg2);
31344 wxPyEndAllowThreads(__tstate);
31345 if (PyErr_Occurred()) SWIG_fail;
31346 }
31347 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
31348 return resultobj;
31349 fail:
31350 return NULL;
31351 }
31352
31353
31354 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31355 PyObject *resultobj = 0;
31356 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31357 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31358 bool result;
31359 void *argp1 = 0 ;
31360 int res1 = 0 ;
31361 void *argp2 = 0 ;
31362 int res2 = 0 ;
31363 PyObject * obj0 = 0 ;
31364 PyObject * obj1 = 0 ;
31365 char * kwnames[] = {
31366 (char *) "self",(char *) "other", NULL
31367 };
31368
31369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
31370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31371 if (!SWIG_IsOK(res1)) {
31372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31373 }
31374 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31376 if (!SWIG_IsOK(res2)) {
31377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31378 }
31379 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31380 {
31381 PyThreadState* __tstate = wxPyBeginAllowThreads();
31382 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
31383 wxPyEndAllowThreads(__tstate);
31384 if (PyErr_Occurred()) SWIG_fail;
31385 }
31386 {
31387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31388 }
31389 return resultobj;
31390 fail:
31391 return NULL;
31392 }
31393
31394
31395 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31396 PyObject *resultobj = 0;
31397 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
31398 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
31399 bool result;
31400 void *argp1 = 0 ;
31401 int res1 = 0 ;
31402 void *argp2 = 0 ;
31403 int res2 = 0 ;
31404 PyObject * obj0 = 0 ;
31405 PyObject * obj1 = 0 ;
31406 char * kwnames[] = {
31407 (char *) "self",(char *) "other", NULL
31408 };
31409
31410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
31411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31412 if (!SWIG_IsOK(res1)) {
31413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
31414 }
31415 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
31416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
31417 if (!SWIG_IsOK(res2)) {
31418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
31419 }
31420 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
31421 {
31422 PyThreadState* __tstate = wxPyBeginAllowThreads();
31423 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
31424 wxPyEndAllowThreads(__tstate);
31425 if (PyErr_Occurred()) SWIG_fail;
31426 }
31427 {
31428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31429 }
31430 return resultobj;
31431 fail:
31432 return NULL;
31433 }
31434
31435
31436 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31437 PyObject *obj;
31438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31439 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
31440 return SWIG_Py_Void();
31441 }
31442
31443 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31444 return SWIG_Python_InitShadowInstance(args);
31445 }
31446
31447 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31448 PyObject *resultobj = 0;
31449 long result;
31450
31451 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
31452 {
31453 PyThreadState* __tstate = wxPyBeginAllowThreads();
31454 result = (long)wxGetLocalTime();
31455 wxPyEndAllowThreads(__tstate);
31456 if (PyErr_Occurred()) SWIG_fail;
31457 }
31458 resultobj = SWIG_From_long(static_cast< long >(result));
31459 return resultobj;
31460 fail:
31461 return NULL;
31462 }
31463
31464
31465 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31466 PyObject *resultobj = 0;
31467 long result;
31468
31469 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
31470 {
31471 PyThreadState* __tstate = wxPyBeginAllowThreads();
31472 result = (long)wxGetUTCTime();
31473 wxPyEndAllowThreads(__tstate);
31474 if (PyErr_Occurred()) SWIG_fail;
31475 }
31476 resultobj = SWIG_From_long(static_cast< long >(result));
31477 return resultobj;
31478 fail:
31479 return NULL;
31480 }
31481
31482
31483 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31484 PyObject *resultobj = 0;
31485 long result;
31486
31487 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
31488 {
31489 PyThreadState* __tstate = wxPyBeginAllowThreads();
31490 result = (long)wxGetCurrentTime();
31491 wxPyEndAllowThreads(__tstate);
31492 if (PyErr_Occurred()) SWIG_fail;
31493 }
31494 resultobj = SWIG_From_long(static_cast< long >(result));
31495 return resultobj;
31496 fail:
31497 return NULL;
31498 }
31499
31500
31501 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31502 PyObject *resultobj = 0;
31503 wxLongLong result;
31504
31505 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
31506 {
31507 PyThreadState* __tstate = wxPyBeginAllowThreads();
31508 result = wxGetLocalTimeMillis();
31509 wxPyEndAllowThreads(__tstate);
31510 if (PyErr_Occurred()) SWIG_fail;
31511 }
31512 {
31513 PyObject *hi, *lo, *shifter, *shifted;
31514 hi = PyLong_FromLong( (&result)->GetHi() );
31515 lo = PyLong_FromLong( (&result)->GetLo() );
31516 shifter = PyLong_FromLong(32);
31517 shifted = PyNumber_Lshift(hi, shifter);
31518 resultobj = PyNumber_Or(shifted, lo);
31519 Py_DECREF(hi);
31520 Py_DECREF(lo);
31521 Py_DECREF(shifter);
31522 Py_DECREF(shifted);
31523 }
31524 return resultobj;
31525 fail:
31526 return NULL;
31527 }
31528
31529
31530 SWIGINTERN int DefaultDateTime_set(PyObject *) {
31531 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
31532 return 1;
31533 }
31534
31535
31536 SWIGINTERN PyObject *DefaultDateTime_get(void) {
31537 PyObject *pyobj = 0;
31538
31539 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
31540 return pyobj;
31541 }
31542
31543
31544 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31545 PyObject *resultobj = 0;
31546 wxDataFormatId arg1 ;
31547 wxDataFormat *result = 0 ;
31548 int val1 ;
31549 int ecode1 = 0 ;
31550 PyObject * obj0 = 0 ;
31551 char * kwnames[] = {
31552 (char *) "type", NULL
31553 };
31554
31555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
31556 ecode1 = SWIG_AsVal_int(obj0, &val1);
31557 if (!SWIG_IsOK(ecode1)) {
31558 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
31559 }
31560 arg1 = static_cast< wxDataFormatId >(val1);
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 result = (wxDataFormat *)new wxDataFormat(arg1);
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
31568 return resultobj;
31569 fail:
31570 return NULL;
31571 }
31572
31573
31574 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31575 PyObject *resultobj = 0;
31576 wxString *arg1 = 0 ;
31577 wxDataFormat *result = 0 ;
31578 bool temp1 = false ;
31579 PyObject * obj0 = 0 ;
31580 char * kwnames[] = {
31581 (char *) "format", NULL
31582 };
31583
31584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
31585 {
31586 arg1 = wxString_in_helper(obj0);
31587 if (arg1 == NULL) SWIG_fail;
31588 temp1 = true;
31589 }
31590 {
31591 PyThreadState* __tstate = wxPyBeginAllowThreads();
31592 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
31593 wxPyEndAllowThreads(__tstate);
31594 if (PyErr_Occurred()) SWIG_fail;
31595 }
31596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31597 {
31598 if (temp1)
31599 delete arg1;
31600 }
31601 return resultobj;
31602 fail:
31603 {
31604 if (temp1)
31605 delete arg1;
31606 }
31607 return NULL;
31608 }
31609
31610
31611 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31612 PyObject *resultobj = 0;
31613 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31614 void *argp1 = 0 ;
31615 int res1 = 0 ;
31616 PyObject *swig_obj[1] ;
31617
31618 if (!args) SWIG_fail;
31619 swig_obj[0] = args;
31620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
31621 if (!SWIG_IsOK(res1)) {
31622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31623 }
31624 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31625 {
31626 PyThreadState* __tstate = wxPyBeginAllowThreads();
31627 delete arg1;
31628
31629 wxPyEndAllowThreads(__tstate);
31630 if (PyErr_Occurred()) SWIG_fail;
31631 }
31632 resultobj = SWIG_Py_Void();
31633 return resultobj;
31634 fail:
31635 return NULL;
31636 }
31637
31638
31639 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31640 PyObject *resultobj = 0;
31641 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31642 wxDataFormatId arg2 ;
31643 bool result;
31644 void *argp1 = 0 ;
31645 int res1 = 0 ;
31646 int val2 ;
31647 int ecode2 = 0 ;
31648
31649 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31651 if (!SWIG_IsOK(res1)) {
31652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31653 }
31654 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31655 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31656 if (!SWIG_IsOK(ecode2)) {
31657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31658 }
31659 arg2 = static_cast< wxDataFormatId >(val2);
31660 {
31661 PyThreadState* __tstate = wxPyBeginAllowThreads();
31662 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
31663 wxPyEndAllowThreads(__tstate);
31664 if (PyErr_Occurred()) SWIG_fail;
31665 }
31666 {
31667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31668 }
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31676 PyObject *resultobj = 0;
31677 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31678 wxDataFormatId arg2 ;
31679 bool result;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 int val2 ;
31683 int ecode2 = 0 ;
31684
31685 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31689 }
31690 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31691 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
31692 if (!SWIG_IsOK(ecode2)) {
31693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31694 }
31695 arg2 = static_cast< wxDataFormatId >(val2);
31696 {
31697 PyThreadState* __tstate = wxPyBeginAllowThreads();
31698 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
31699 wxPyEndAllowThreads(__tstate);
31700 if (PyErr_Occurred()) SWIG_fail;
31701 }
31702 {
31703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31704 }
31705 return resultobj;
31706 fail:
31707 return NULL;
31708 }
31709
31710
31711 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31712 PyObject *resultobj = 0;
31713 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31714 wxDataFormat *arg2 = 0 ;
31715 bool result;
31716 void *argp1 = 0 ;
31717 int res1 = 0 ;
31718 void *argp2 = 0 ;
31719 int res2 = 0 ;
31720
31721 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31723 if (!SWIG_IsOK(res1)) {
31724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31725 }
31726 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31727 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31728 if (!SWIG_IsOK(res2)) {
31729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31730 }
31731 if (!argp2) {
31732 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31733 }
31734 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31735 {
31736 PyThreadState* __tstate = wxPyBeginAllowThreads();
31737 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
31738 wxPyEndAllowThreads(__tstate);
31739 if (PyErr_Occurred()) SWIG_fail;
31740 }
31741 {
31742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31743 }
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
31751 int argc;
31752 PyObject *argv[3];
31753
31754 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
31755 --argc;
31756 if (argc == 2) {
31757 int _v = 0;
31758 {
31759 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31760 _v = SWIG_CheckState(res);
31761 }
31762 if (!_v) goto check_1;
31763 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
31764 }
31765 check_1:
31766
31767 if (argc == 2) {
31768 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
31769 }
31770
31771 fail:
31772 Py_INCREF(Py_NotImplemented);
31773 return Py_NotImplemented;
31774 }
31775
31776
31777 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31778 PyObject *resultobj = 0;
31779 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31780 wxDataFormat *arg2 = 0 ;
31781 bool result;
31782 void *argp1 = 0 ;
31783 int res1 = 0 ;
31784 void *argp2 = 0 ;
31785 int res2 = 0 ;
31786
31787 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
31788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31789 if (!SWIG_IsOK(res1)) {
31790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31791 }
31792 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31793 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31794 if (!SWIG_IsOK(res2)) {
31795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31796 }
31797 if (!argp2) {
31798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31799 }
31800 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 {
31808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31809 }
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
31817 int argc;
31818 PyObject *argv[3];
31819
31820 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
31821 --argc;
31822 if (argc == 2) {
31823 int _v = 0;
31824 {
31825 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
31826 _v = SWIG_CheckState(res);
31827 }
31828 if (!_v) goto check_1;
31829 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
31830 }
31831 check_1:
31832
31833 if (argc == 2) {
31834 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
31835 }
31836
31837 fail:
31838 Py_INCREF(Py_NotImplemented);
31839 return Py_NotImplemented;
31840 }
31841
31842
31843 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31844 PyObject *resultobj = 0;
31845 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31846 wxDataFormatId arg2 ;
31847 void *argp1 = 0 ;
31848 int res1 = 0 ;
31849 int val2 ;
31850 int ecode2 = 0 ;
31851 PyObject * obj0 = 0 ;
31852 PyObject * obj1 = 0 ;
31853 char * kwnames[] = {
31854 (char *) "self",(char *) "format", NULL
31855 };
31856
31857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
31858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31859 if (!SWIG_IsOK(res1)) {
31860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31861 }
31862 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31863 ecode2 = SWIG_AsVal_int(obj1, &val2);
31864 if (!SWIG_IsOK(ecode2)) {
31865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
31866 }
31867 arg2 = static_cast< wxDataFormatId >(val2);
31868 {
31869 PyThreadState* __tstate = wxPyBeginAllowThreads();
31870 (arg1)->SetType(arg2);
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_Py_Void();
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31882 PyObject *resultobj = 0;
31883 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31884 wxDataFormatId result;
31885 void *argp1 = 0 ;
31886 int res1 = 0 ;
31887 PyObject *swig_obj[1] ;
31888
31889 if (!args) SWIG_fail;
31890 swig_obj[0] = args;
31891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31892 if (!SWIG_IsOK(res1)) {
31893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31894 }
31895 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31896 {
31897 PyThreadState* __tstate = wxPyBeginAllowThreads();
31898 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
31899 wxPyEndAllowThreads(__tstate);
31900 if (PyErr_Occurred()) SWIG_fail;
31901 }
31902 resultobj = SWIG_From_int(static_cast< int >(result));
31903 return resultobj;
31904 fail:
31905 return NULL;
31906 }
31907
31908
31909 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31910 PyObject *resultobj = 0;
31911 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31912 wxString result;
31913 void *argp1 = 0 ;
31914 int res1 = 0 ;
31915 PyObject *swig_obj[1] ;
31916
31917 if (!args) SWIG_fail;
31918 swig_obj[0] = args;
31919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31920 if (!SWIG_IsOK(res1)) {
31921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
31922 }
31923 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31924 {
31925 PyThreadState* __tstate = wxPyBeginAllowThreads();
31926 result = ((wxDataFormat const *)arg1)->GetId();
31927 wxPyEndAllowThreads(__tstate);
31928 if (PyErr_Occurred()) SWIG_fail;
31929 }
31930 {
31931 #if wxUSE_UNICODE
31932 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31933 #else
31934 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31935 #endif
31936 }
31937 return resultobj;
31938 fail:
31939 return NULL;
31940 }
31941
31942
31943 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31944 PyObject *resultobj = 0;
31945 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
31946 wxString *arg2 = 0 ;
31947 void *argp1 = 0 ;
31948 int res1 = 0 ;
31949 bool temp2 = false ;
31950 PyObject * obj0 = 0 ;
31951 PyObject * obj1 = 0 ;
31952 char * kwnames[] = {
31953 (char *) "self",(char *) "format", NULL
31954 };
31955
31956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
31958 if (!SWIG_IsOK(res1)) {
31959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
31960 }
31961 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31962 {
31963 arg2 = wxString_in_helper(obj1);
31964 if (arg2 == NULL) SWIG_fail;
31965 temp2 = true;
31966 }
31967 {
31968 PyThreadState* __tstate = wxPyBeginAllowThreads();
31969 (arg1)->SetId((wxString const &)*arg2);
31970 wxPyEndAllowThreads(__tstate);
31971 if (PyErr_Occurred()) SWIG_fail;
31972 }
31973 resultobj = SWIG_Py_Void();
31974 {
31975 if (temp2)
31976 delete arg2;
31977 }
31978 return resultobj;
31979 fail:
31980 {
31981 if (temp2)
31982 delete arg2;
31983 }
31984 return NULL;
31985 }
31986
31987
31988 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31989 PyObject *obj;
31990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31991 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
31992 return SWIG_Py_Void();
31993 }
31994
31995 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31996 return SWIG_Python_InitShadowInstance(args);
31997 }
31998
31999 SWIGINTERN int FormatInvalid_set(PyObject *) {
32000 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
32001 return 1;
32002 }
32003
32004
32005 SWIGINTERN PyObject *FormatInvalid_get(void) {
32006 PyObject *pyobj = 0;
32007
32008 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
32009 return pyobj;
32010 }
32011
32012
32013 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32014 PyObject *resultobj = 0;
32015 wxDataObject *arg1 = (wxDataObject *) 0 ;
32016 void *argp1 = 0 ;
32017 int res1 = 0 ;
32018 PyObject *swig_obj[1] ;
32019
32020 if (!args) SWIG_fail;
32021 swig_obj[0] = args;
32022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32023 if (!SWIG_IsOK(res1)) {
32024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
32025 }
32026 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32027 {
32028 PyThreadState* __tstate = wxPyBeginAllowThreads();
32029 delete arg1;
32030
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 resultobj = SWIG_Py_Void();
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32042 PyObject *resultobj = 0;
32043 wxDataObject *arg1 = (wxDataObject *) 0 ;
32044 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32045 SwigValueWrapper<wxDataFormat > result;
32046 void *argp1 = 0 ;
32047 int res1 = 0 ;
32048 int val2 ;
32049 int ecode2 = 0 ;
32050 PyObject * obj0 = 0 ;
32051 PyObject * obj1 = 0 ;
32052 char * kwnames[] = {
32053 (char *) "self",(char *) "dir", NULL
32054 };
32055
32056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32058 if (!SWIG_IsOK(res1)) {
32059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32060 }
32061 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32062 if (obj1) {
32063 ecode2 = SWIG_AsVal_int(obj1, &val2);
32064 if (!SWIG_IsOK(ecode2)) {
32065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32066 }
32067 arg2 = static_cast< wxDataObject::Direction >(val2);
32068 }
32069 {
32070 PyThreadState* __tstate = wxPyBeginAllowThreads();
32071 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
32072 wxPyEndAllowThreads(__tstate);
32073 if (PyErr_Occurred()) SWIG_fail;
32074 }
32075 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32076 return resultobj;
32077 fail:
32078 return NULL;
32079 }
32080
32081
32082 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32083 PyObject *resultobj = 0;
32084 wxDataObject *arg1 = (wxDataObject *) 0 ;
32085 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32086 size_t result;
32087 void *argp1 = 0 ;
32088 int res1 = 0 ;
32089 int val2 ;
32090 int ecode2 = 0 ;
32091 PyObject * obj0 = 0 ;
32092 PyObject * obj1 = 0 ;
32093 char * kwnames[] = {
32094 (char *) "self",(char *) "dir", NULL
32095 };
32096
32097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
32098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32099 if (!SWIG_IsOK(res1)) {
32100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32101 }
32102 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32103 if (obj1) {
32104 ecode2 = SWIG_AsVal_int(obj1, &val2);
32105 if (!SWIG_IsOK(ecode2)) {
32106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32107 }
32108 arg2 = static_cast< wxDataObject::Direction >(val2);
32109 }
32110 {
32111 PyThreadState* __tstate = wxPyBeginAllowThreads();
32112 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
32113 wxPyEndAllowThreads(__tstate);
32114 if (PyErr_Occurred()) SWIG_fail;
32115 }
32116 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32117 return resultobj;
32118 fail:
32119 return NULL;
32120 }
32121
32122
32123 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32124 PyObject *resultobj = 0;
32125 wxDataObject *arg1 = (wxDataObject *) 0 ;
32126 wxDataFormat *arg2 = 0 ;
32127 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
32128 bool result;
32129 void *argp1 = 0 ;
32130 int res1 = 0 ;
32131 void *argp2 = 0 ;
32132 int res2 = 0 ;
32133 int val3 ;
32134 int ecode3 = 0 ;
32135 PyObject * obj0 = 0 ;
32136 PyObject * obj1 = 0 ;
32137 PyObject * obj2 = 0 ;
32138 char * kwnames[] = {
32139 (char *) "self",(char *) "format",(char *) "dir", NULL
32140 };
32141
32142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32144 if (!SWIG_IsOK(res1)) {
32145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32146 }
32147 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32148 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32149 if (!SWIG_IsOK(res2)) {
32150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32151 }
32152 if (!argp2) {
32153 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32154 }
32155 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32156 if (obj2) {
32157 ecode3 = SWIG_AsVal_int(obj2, &val3);
32158 if (!SWIG_IsOK(ecode3)) {
32159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
32160 }
32161 arg3 = static_cast< wxDataObject::Direction >(val3);
32162 }
32163 {
32164 PyThreadState* __tstate = wxPyBeginAllowThreads();
32165 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
32166 wxPyEndAllowThreads(__tstate);
32167 if (PyErr_Occurred()) SWIG_fail;
32168 }
32169 {
32170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32171 }
32172 return resultobj;
32173 fail:
32174 return NULL;
32175 }
32176
32177
32178 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32179 PyObject *resultobj = 0;
32180 wxDataObject *arg1 = (wxDataObject *) 0 ;
32181 wxDataFormat *arg2 = 0 ;
32182 size_t result;
32183 void *argp1 = 0 ;
32184 int res1 = 0 ;
32185 void *argp2 = 0 ;
32186 int res2 = 0 ;
32187 PyObject * obj0 = 0 ;
32188 PyObject * obj1 = 0 ;
32189 char * kwnames[] = {
32190 (char *) "self",(char *) "format", NULL
32191 };
32192
32193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
32194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32195 if (!SWIG_IsOK(res1)) {
32196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
32197 }
32198 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32199 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32200 if (!SWIG_IsOK(res2)) {
32201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32202 }
32203 if (!argp2) {
32204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32205 }
32206 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32207 {
32208 PyThreadState* __tstate = wxPyBeginAllowThreads();
32209 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
32210 wxPyEndAllowThreads(__tstate);
32211 if (PyErr_Occurred()) SWIG_fail;
32212 }
32213 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32214 return resultobj;
32215 fail:
32216 return NULL;
32217 }
32218
32219
32220 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32221 PyObject *resultobj = 0;
32222 wxDataObject *arg1 = (wxDataObject *) 0 ;
32223 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
32224 PyObject *result = 0 ;
32225 void *argp1 = 0 ;
32226 int res1 = 0 ;
32227 int val2 ;
32228 int ecode2 = 0 ;
32229 PyObject * obj0 = 0 ;
32230 PyObject * obj1 = 0 ;
32231 char * kwnames[] = {
32232 (char *) "self",(char *) "dir", NULL
32233 };
32234
32235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
32236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32237 if (!SWIG_IsOK(res1)) {
32238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
32239 }
32240 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32241 if (obj1) {
32242 ecode2 = SWIG_AsVal_int(obj1, &val2);
32243 if (!SWIG_IsOK(ecode2)) {
32244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
32245 }
32246 arg2 = static_cast< wxDataObject::Direction >(val2);
32247 }
32248 {
32249 PyThreadState* __tstate = wxPyBeginAllowThreads();
32250 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
32251 wxPyEndAllowThreads(__tstate);
32252 if (PyErr_Occurred()) SWIG_fail;
32253 }
32254 resultobj = result;
32255 return resultobj;
32256 fail:
32257 return NULL;
32258 }
32259
32260
32261 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32262 PyObject *resultobj = 0;
32263 wxDataObject *arg1 = (wxDataObject *) 0 ;
32264 wxDataFormat *arg2 = 0 ;
32265 PyObject *result = 0 ;
32266 void *argp1 = 0 ;
32267 int res1 = 0 ;
32268 void *argp2 = 0 ;
32269 int res2 = 0 ;
32270 PyObject * obj0 = 0 ;
32271 PyObject * obj1 = 0 ;
32272 char * kwnames[] = {
32273 (char *) "self",(char *) "format", NULL
32274 };
32275
32276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
32277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32278 if (!SWIG_IsOK(res1)) {
32279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
32280 }
32281 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32282 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32283 if (!SWIG_IsOK(res2)) {
32284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32285 }
32286 if (!argp2) {
32287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32288 }
32289 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 resultobj = result;
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32304 PyObject *resultobj = 0;
32305 wxDataObject *arg1 = (wxDataObject *) 0 ;
32306 wxDataFormat *arg2 = 0 ;
32307 PyObject *arg3 = (PyObject *) 0 ;
32308 bool result;
32309 void *argp1 = 0 ;
32310 int res1 = 0 ;
32311 void *argp2 = 0 ;
32312 int res2 = 0 ;
32313 PyObject * obj0 = 0 ;
32314 PyObject * obj1 = 0 ;
32315 PyObject * obj2 = 0 ;
32316 char * kwnames[] = {
32317 (char *) "self",(char *) "format",(char *) "data", NULL
32318 };
32319
32320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
32322 if (!SWIG_IsOK(res1)) {
32323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
32324 }
32325 arg1 = reinterpret_cast< wxDataObject * >(argp1);
32326 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32327 if (!SWIG_IsOK(res2)) {
32328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32329 }
32330 if (!argp2) {
32331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32332 }
32333 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32334 arg3 = obj2;
32335 {
32336 PyThreadState* __tstate = wxPyBeginAllowThreads();
32337 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
32338 wxPyEndAllowThreads(__tstate);
32339 if (PyErr_Occurred()) SWIG_fail;
32340 }
32341 {
32342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32343 }
32344 return resultobj;
32345 fail:
32346 return NULL;
32347 }
32348
32349
32350 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32351 PyObject *obj;
32352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32353 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
32354 return SWIG_Py_Void();
32355 }
32356
32357 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32358 PyObject *resultobj = 0;
32359 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32360 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32361 wxDataObjectSimple *result = 0 ;
32362 void *argp1 = 0 ;
32363 int res1 = 0 ;
32364 PyObject * obj0 = 0 ;
32365 char * kwnames[] = {
32366 (char *) "format", NULL
32367 };
32368
32369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
32370 if (obj0) {
32371 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32372 if (!SWIG_IsOK(res1)) {
32373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32374 }
32375 if (!argp1) {
32376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32377 }
32378 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32379 }
32380 {
32381 PyThreadState* __tstate = wxPyBeginAllowThreads();
32382 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
32387 return resultobj;
32388 fail:
32389 return NULL;
32390 }
32391
32392
32393 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32394 PyObject *resultobj = 0;
32395 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32396 wxDataFormat *result = 0 ;
32397 void *argp1 = 0 ;
32398 int res1 = 0 ;
32399 PyObject *swig_obj[1] ;
32400
32401 if (!args) SWIG_fail;
32402 swig_obj[0] = args;
32403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32404 if (!SWIG_IsOK(res1)) {
32405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32406 }
32407 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32408 {
32409 PyThreadState* __tstate = wxPyBeginAllowThreads();
32410 {
32411 wxDataFormat const &_result_ref = (arg1)->GetFormat();
32412 result = (wxDataFormat *) &_result_ref;
32413 }
32414 wxPyEndAllowThreads(__tstate);
32415 if (PyErr_Occurred()) SWIG_fail;
32416 }
32417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32425 PyObject *resultobj = 0;
32426 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32427 wxDataFormat *arg2 = 0 ;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 void *argp2 = 0 ;
32431 int res2 = 0 ;
32432 PyObject * obj0 = 0 ;
32433 PyObject * obj1 = 0 ;
32434 char * kwnames[] = {
32435 (char *) "self",(char *) "format", NULL
32436 };
32437
32438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
32439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32440 if (!SWIG_IsOK(res1)) {
32441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32442 }
32443 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32444 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
32445 if (!SWIG_IsOK(res2)) {
32446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32447 }
32448 if (!argp2) {
32449 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
32450 }
32451 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
32452 {
32453 PyThreadState* __tstate = wxPyBeginAllowThreads();
32454 (arg1)->SetFormat((wxDataFormat const &)*arg2);
32455 wxPyEndAllowThreads(__tstate);
32456 if (PyErr_Occurred()) SWIG_fail;
32457 }
32458 resultobj = SWIG_Py_Void();
32459 return resultobj;
32460 fail:
32461 return NULL;
32462 }
32463
32464
32465 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32466 PyObject *resultobj = 0;
32467 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32468 size_t result;
32469 void *argp1 = 0 ;
32470 int res1 = 0 ;
32471 PyObject *swig_obj[1] ;
32472
32473 if (!args) SWIG_fail;
32474 swig_obj[0] = args;
32475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32476 if (!SWIG_IsOK(res1)) {
32477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
32478 }
32479 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32480 {
32481 PyThreadState* __tstate = wxPyBeginAllowThreads();
32482 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
32483 wxPyEndAllowThreads(__tstate);
32484 if (PyErr_Occurred()) SWIG_fail;
32485 }
32486 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32487 return resultobj;
32488 fail:
32489 return NULL;
32490 }
32491
32492
32493 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32494 PyObject *resultobj = 0;
32495 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32496 PyObject *result = 0 ;
32497 void *argp1 = 0 ;
32498 int res1 = 0 ;
32499 PyObject *swig_obj[1] ;
32500
32501 if (!args) SWIG_fail;
32502 swig_obj[0] = args;
32503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32504 if (!SWIG_IsOK(res1)) {
32505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32506 }
32507 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32508 {
32509 PyThreadState* __tstate = wxPyBeginAllowThreads();
32510 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
32511 wxPyEndAllowThreads(__tstate);
32512 if (PyErr_Occurred()) SWIG_fail;
32513 }
32514 resultobj = result;
32515 return resultobj;
32516 fail:
32517 return NULL;
32518 }
32519
32520
32521 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32522 PyObject *resultobj = 0;
32523 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
32524 PyObject *arg2 = (PyObject *) 0 ;
32525 bool result;
32526 void *argp1 = 0 ;
32527 int res1 = 0 ;
32528 PyObject * obj0 = 0 ;
32529 PyObject * obj1 = 0 ;
32530 char * kwnames[] = {
32531 (char *) "self",(char *) "data", NULL
32532 };
32533
32534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
32536 if (!SWIG_IsOK(res1)) {
32537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
32538 }
32539 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
32540 arg2 = obj1;
32541 {
32542 PyThreadState* __tstate = wxPyBeginAllowThreads();
32543 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
32544 wxPyEndAllowThreads(__tstate);
32545 if (PyErr_Occurred()) SWIG_fail;
32546 }
32547 {
32548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32549 }
32550 return resultobj;
32551 fail:
32552 return NULL;
32553 }
32554
32555
32556 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32557 PyObject *obj;
32558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32559 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
32560 return SWIG_Py_Void();
32561 }
32562
32563 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32564 return SWIG_Python_InitShadowInstance(args);
32565 }
32566
32567 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32568 PyObject *resultobj = 0;
32569 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
32570 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
32571 wxPyDataObjectSimple *result = 0 ;
32572 void *argp1 = 0 ;
32573 int res1 = 0 ;
32574 PyObject * obj0 = 0 ;
32575 char * kwnames[] = {
32576 (char *) "format", NULL
32577 };
32578
32579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
32580 if (obj0) {
32581 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32582 if (!SWIG_IsOK(res1)) {
32583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32584 }
32585 if (!argp1) {
32586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32587 }
32588 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32589 }
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
32593 wxPyEndAllowThreads(__tstate);
32594 if (PyErr_Occurred()) SWIG_fail;
32595 }
32596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
32597 return resultobj;
32598 fail:
32599 return NULL;
32600 }
32601
32602
32603 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32604 PyObject *resultobj = 0;
32605 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
32606 PyObject *arg2 = (PyObject *) 0 ;
32607 PyObject *arg3 = (PyObject *) 0 ;
32608 void *argp1 = 0 ;
32609 int res1 = 0 ;
32610 PyObject * obj0 = 0 ;
32611 PyObject * obj1 = 0 ;
32612 PyObject * obj2 = 0 ;
32613 char * kwnames[] = {
32614 (char *) "self",(char *) "self",(char *) "_class", NULL
32615 };
32616
32617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
32619 if (!SWIG_IsOK(res1)) {
32620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
32621 }
32622 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
32623 arg2 = obj1;
32624 arg3 = obj2;
32625 {
32626 PyThreadState* __tstate = wxPyBeginAllowThreads();
32627 (arg1)->_setCallbackInfo(arg2,arg3);
32628 wxPyEndAllowThreads(__tstate);
32629 if (PyErr_Occurred()) SWIG_fail;
32630 }
32631 resultobj = SWIG_Py_Void();
32632 return resultobj;
32633 fail:
32634 return NULL;
32635 }
32636
32637
32638 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32639 PyObject *obj;
32640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32641 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
32642 return SWIG_Py_Void();
32643 }
32644
32645 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32646 return SWIG_Python_InitShadowInstance(args);
32647 }
32648
32649 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32650 PyObject *resultobj = 0;
32651 wxDataObjectComposite *result = 0 ;
32652
32653 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
32654 {
32655 PyThreadState* __tstate = wxPyBeginAllowThreads();
32656 result = (wxDataObjectComposite *)new wxDataObjectComposite();
32657 wxPyEndAllowThreads(__tstate);
32658 if (PyErr_Occurred()) SWIG_fail;
32659 }
32660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
32661 return resultobj;
32662 fail:
32663 return NULL;
32664 }
32665
32666
32667 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32668 PyObject *resultobj = 0;
32669 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32670 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
32671 bool arg3 = (bool) false ;
32672 void *argp1 = 0 ;
32673 int res1 = 0 ;
32674 int res2 = 0 ;
32675 bool val3 ;
32676 int ecode3 = 0 ;
32677 PyObject * obj0 = 0 ;
32678 PyObject * obj1 = 0 ;
32679 PyObject * obj2 = 0 ;
32680 char * kwnames[] = {
32681 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
32682 };
32683
32684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32686 if (!SWIG_IsOK(res1)) {
32687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
32688 }
32689 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32690 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
32691 if (!SWIG_IsOK(res2)) {
32692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
32693 }
32694 if (obj2) {
32695 ecode3 = SWIG_AsVal_bool(obj2, &val3);
32696 if (!SWIG_IsOK(ecode3)) {
32697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
32698 }
32699 arg3 = static_cast< bool >(val3);
32700 }
32701 {
32702 PyThreadState* __tstate = wxPyBeginAllowThreads();
32703 (arg1)->Add(arg2,arg3);
32704 wxPyEndAllowThreads(__tstate);
32705 if (PyErr_Occurred()) SWIG_fail;
32706 }
32707 resultobj = SWIG_Py_Void();
32708 return resultobj;
32709 fail:
32710 return NULL;
32711 }
32712
32713
32714 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32715 PyObject *resultobj = 0;
32716 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
32717 SwigValueWrapper<wxDataFormat > result;
32718 void *argp1 = 0 ;
32719 int res1 = 0 ;
32720 PyObject *swig_obj[1] ;
32721
32722 if (!args) SWIG_fail;
32723 swig_obj[0] = args;
32724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
32725 if (!SWIG_IsOK(res1)) {
32726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
32727 }
32728 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
32729 {
32730 PyThreadState* __tstate = wxPyBeginAllowThreads();
32731 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
32732 wxPyEndAllowThreads(__tstate);
32733 if (PyErr_Occurred()) SWIG_fail;
32734 }
32735 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
32736 return resultobj;
32737 fail:
32738 return NULL;
32739 }
32740
32741
32742 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32743 PyObject *obj;
32744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32745 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
32746 return SWIG_Py_Void();
32747 }
32748
32749 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32750 return SWIG_Python_InitShadowInstance(args);
32751 }
32752
32753 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32754 PyObject *resultobj = 0;
32755 wxString const &arg1_defvalue = wxPyEmptyString ;
32756 wxString *arg1 = (wxString *) &arg1_defvalue ;
32757 wxTextDataObject *result = 0 ;
32758 bool temp1 = false ;
32759 PyObject * obj0 = 0 ;
32760 char * kwnames[] = {
32761 (char *) "text", NULL
32762 };
32763
32764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
32765 if (obj0) {
32766 {
32767 arg1 = wxString_in_helper(obj0);
32768 if (arg1 == NULL) SWIG_fail;
32769 temp1 = true;
32770 }
32771 }
32772 {
32773 PyThreadState* __tstate = wxPyBeginAllowThreads();
32774 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
32775 wxPyEndAllowThreads(__tstate);
32776 if (PyErr_Occurred()) SWIG_fail;
32777 }
32778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
32779 {
32780 if (temp1)
32781 delete arg1;
32782 }
32783 return resultobj;
32784 fail:
32785 {
32786 if (temp1)
32787 delete arg1;
32788 }
32789 return NULL;
32790 }
32791
32792
32793 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32794 PyObject *resultobj = 0;
32795 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32796 size_t result;
32797 void *argp1 = 0 ;
32798 int res1 = 0 ;
32799 PyObject *swig_obj[1] ;
32800
32801 if (!args) SWIG_fail;
32802 swig_obj[0] = args;
32803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32804 if (!SWIG_IsOK(res1)) {
32805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32806 }
32807 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32808 {
32809 PyThreadState* __tstate = wxPyBeginAllowThreads();
32810 result = (size_t)(arg1)->GetTextLength();
32811 wxPyEndAllowThreads(__tstate);
32812 if (PyErr_Occurred()) SWIG_fail;
32813 }
32814 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32815 return resultobj;
32816 fail:
32817 return NULL;
32818 }
32819
32820
32821 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32822 PyObject *resultobj = 0;
32823 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32824 wxString result;
32825 void *argp1 = 0 ;
32826 int res1 = 0 ;
32827 PyObject *swig_obj[1] ;
32828
32829 if (!args) SWIG_fail;
32830 swig_obj[0] = args;
32831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32832 if (!SWIG_IsOK(res1)) {
32833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32834 }
32835 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32836 {
32837 PyThreadState* __tstate = wxPyBeginAllowThreads();
32838 result = (arg1)->GetText();
32839 wxPyEndAllowThreads(__tstate);
32840 if (PyErr_Occurred()) SWIG_fail;
32841 }
32842 {
32843 #if wxUSE_UNICODE
32844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32845 #else
32846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32847 #endif
32848 }
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32856 PyObject *resultobj = 0;
32857 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
32858 wxString *arg2 = 0 ;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 bool temp2 = false ;
32862 PyObject * obj0 = 0 ;
32863 PyObject * obj1 = 0 ;
32864 char * kwnames[] = {
32865 (char *) "self",(char *) "text", NULL
32866 };
32867
32868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
32869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
32870 if (!SWIG_IsOK(res1)) {
32871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
32872 }
32873 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
32874 {
32875 arg2 = wxString_in_helper(obj1);
32876 if (arg2 == NULL) SWIG_fail;
32877 temp2 = true;
32878 }
32879 {
32880 PyThreadState* __tstate = wxPyBeginAllowThreads();
32881 (arg1)->SetText((wxString const &)*arg2);
32882 wxPyEndAllowThreads(__tstate);
32883 if (PyErr_Occurred()) SWIG_fail;
32884 }
32885 resultobj = SWIG_Py_Void();
32886 {
32887 if (temp2)
32888 delete arg2;
32889 }
32890 return resultobj;
32891 fail:
32892 {
32893 if (temp2)
32894 delete arg2;
32895 }
32896 return NULL;
32897 }
32898
32899
32900 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32901 PyObject *obj;
32902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32903 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
32904 return SWIG_Py_Void();
32905 }
32906
32907 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32908 return SWIG_Python_InitShadowInstance(args);
32909 }
32910
32911 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32912 PyObject *resultobj = 0;
32913 wxString const &arg1_defvalue = wxPyEmptyString ;
32914 wxString *arg1 = (wxString *) &arg1_defvalue ;
32915 wxPyTextDataObject *result = 0 ;
32916 bool temp1 = false ;
32917 PyObject * obj0 = 0 ;
32918 char * kwnames[] = {
32919 (char *) "text", NULL
32920 };
32921
32922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
32923 if (obj0) {
32924 {
32925 arg1 = wxString_in_helper(obj0);
32926 if (arg1 == NULL) SWIG_fail;
32927 temp1 = true;
32928 }
32929 }
32930 {
32931 PyThreadState* __tstate = wxPyBeginAllowThreads();
32932 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
32937 {
32938 if (temp1)
32939 delete arg1;
32940 }
32941 return resultobj;
32942 fail:
32943 {
32944 if (temp1)
32945 delete arg1;
32946 }
32947 return NULL;
32948 }
32949
32950
32951 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32952 PyObject *resultobj = 0;
32953 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
32954 PyObject *arg2 = (PyObject *) 0 ;
32955 PyObject *arg3 = (PyObject *) 0 ;
32956 void *argp1 = 0 ;
32957 int res1 = 0 ;
32958 PyObject * obj0 = 0 ;
32959 PyObject * obj1 = 0 ;
32960 PyObject * obj2 = 0 ;
32961 char * kwnames[] = {
32962 (char *) "self",(char *) "self",(char *) "_class", NULL
32963 };
32964
32965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
32967 if (!SWIG_IsOK(res1)) {
32968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
32969 }
32970 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
32971 arg2 = obj1;
32972 arg3 = obj2;
32973 {
32974 PyThreadState* __tstate = wxPyBeginAllowThreads();
32975 (arg1)->_setCallbackInfo(arg2,arg3);
32976 wxPyEndAllowThreads(__tstate);
32977 if (PyErr_Occurred()) SWIG_fail;
32978 }
32979 resultobj = SWIG_Py_Void();
32980 return resultobj;
32981 fail:
32982 return NULL;
32983 }
32984
32985
32986 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32987 PyObject *obj;
32988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32989 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
32990 return SWIG_Py_Void();
32991 }
32992
32993 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32994 return SWIG_Python_InitShadowInstance(args);
32995 }
32996
32997 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32998 PyObject *resultobj = 0;
32999 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33000 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33001 wxBitmapDataObject *result = 0 ;
33002 void *argp1 = 0 ;
33003 int res1 = 0 ;
33004 PyObject * obj0 = 0 ;
33005 char * kwnames[] = {
33006 (char *) "bitmap", NULL
33007 };
33008
33009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
33010 if (obj0) {
33011 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33014 }
33015 if (!argp1) {
33016 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33017 }
33018 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33019 }
33020 {
33021 PyThreadState* __tstate = wxPyBeginAllowThreads();
33022 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
33023 wxPyEndAllowThreads(__tstate);
33024 if (PyErr_Occurred()) SWIG_fail;
33025 }
33026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
33027 return resultobj;
33028 fail:
33029 return NULL;
33030 }
33031
33032
33033 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33034 PyObject *resultobj = 0;
33035 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33036 wxBitmap result;
33037 void *argp1 = 0 ;
33038 int res1 = 0 ;
33039 PyObject *swig_obj[1] ;
33040
33041 if (!args) SWIG_fail;
33042 swig_obj[0] = args;
33043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33044 if (!SWIG_IsOK(res1)) {
33045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
33046 }
33047 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33048 {
33049 PyThreadState* __tstate = wxPyBeginAllowThreads();
33050 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
33051 wxPyEndAllowThreads(__tstate);
33052 if (PyErr_Occurred()) SWIG_fail;
33053 }
33054 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
33055 return resultobj;
33056 fail:
33057 return NULL;
33058 }
33059
33060
33061 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33062 PyObject *resultobj = 0;
33063 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
33064 wxBitmap *arg2 = 0 ;
33065 void *argp1 = 0 ;
33066 int res1 = 0 ;
33067 void *argp2 = 0 ;
33068 int res2 = 0 ;
33069 PyObject * obj0 = 0 ;
33070 PyObject * obj1 = 0 ;
33071 char * kwnames[] = {
33072 (char *) "self",(char *) "bitmap", NULL
33073 };
33074
33075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
33076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
33077 if (!SWIG_IsOK(res1)) {
33078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
33079 }
33080 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
33081 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
33082 if (!SWIG_IsOK(res2)) {
33083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33084 }
33085 if (!argp2) {
33086 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
33087 }
33088 arg2 = reinterpret_cast< wxBitmap * >(argp2);
33089 {
33090 PyThreadState* __tstate = wxPyBeginAllowThreads();
33091 (arg1)->SetBitmap((wxBitmap const &)*arg2);
33092 wxPyEndAllowThreads(__tstate);
33093 if (PyErr_Occurred()) SWIG_fail;
33094 }
33095 resultobj = SWIG_Py_Void();
33096 return resultobj;
33097 fail:
33098 return NULL;
33099 }
33100
33101
33102 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33103 PyObject *obj;
33104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33105 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
33106 return SWIG_Py_Void();
33107 }
33108
33109 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33110 return SWIG_Python_InitShadowInstance(args);
33111 }
33112
33113 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33114 PyObject *resultobj = 0;
33115 wxBitmap const &arg1_defvalue = wxNullBitmap ;
33116 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
33117 wxPyBitmapDataObject *result = 0 ;
33118 void *argp1 = 0 ;
33119 int res1 = 0 ;
33120 PyObject * obj0 = 0 ;
33121 char * kwnames[] = {
33122 (char *) "bitmap", NULL
33123 };
33124
33125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
33126 if (obj0) {
33127 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
33128 if (!SWIG_IsOK(res1)) {
33129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33130 }
33131 if (!argp1) {
33132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
33133 }
33134 arg1 = reinterpret_cast< wxBitmap * >(argp1);
33135 }
33136 {
33137 PyThreadState* __tstate = wxPyBeginAllowThreads();
33138 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
33139 wxPyEndAllowThreads(__tstate);
33140 if (PyErr_Occurred()) SWIG_fail;
33141 }
33142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
33143 return resultobj;
33144 fail:
33145 return NULL;
33146 }
33147
33148
33149 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33150 PyObject *resultobj = 0;
33151 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
33152 PyObject *arg2 = (PyObject *) 0 ;
33153 PyObject *arg3 = (PyObject *) 0 ;
33154 void *argp1 = 0 ;
33155 int res1 = 0 ;
33156 PyObject * obj0 = 0 ;
33157 PyObject * obj1 = 0 ;
33158 PyObject * obj2 = 0 ;
33159 char * kwnames[] = {
33160 (char *) "self",(char *) "self",(char *) "_class", NULL
33161 };
33162
33163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
33165 if (!SWIG_IsOK(res1)) {
33166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
33167 }
33168 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
33169 arg2 = obj1;
33170 arg3 = obj2;
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 (arg1)->_setCallbackInfo(arg2,arg3);
33174 wxPyEndAllowThreads(__tstate);
33175 if (PyErr_Occurred()) SWIG_fail;
33176 }
33177 resultobj = SWIG_Py_Void();
33178 return resultobj;
33179 fail:
33180 return NULL;
33181 }
33182
33183
33184 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33185 PyObject *obj;
33186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33187 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
33188 return SWIG_Py_Void();
33189 }
33190
33191 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33192 return SWIG_Python_InitShadowInstance(args);
33193 }
33194
33195 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33196 PyObject *resultobj = 0;
33197 wxFileDataObject *result = 0 ;
33198
33199 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
33200 {
33201 PyThreadState* __tstate = wxPyBeginAllowThreads();
33202 result = (wxFileDataObject *)new wxFileDataObject();
33203 wxPyEndAllowThreads(__tstate);
33204 if (PyErr_Occurred()) SWIG_fail;
33205 }
33206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
33207 return resultobj;
33208 fail:
33209 return NULL;
33210 }
33211
33212
33213 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33214 PyObject *resultobj = 0;
33215 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33216 wxArrayString *result = 0 ;
33217 void *argp1 = 0 ;
33218 int res1 = 0 ;
33219 PyObject *swig_obj[1] ;
33220
33221 if (!args) SWIG_fail;
33222 swig_obj[0] = args;
33223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33224 if (!SWIG_IsOK(res1)) {
33225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33226 }
33227 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33228 {
33229 PyThreadState* __tstate = wxPyBeginAllowThreads();
33230 {
33231 wxArrayString const &_result_ref = (arg1)->GetFilenames();
33232 result = (wxArrayString *) &_result_ref;
33233 }
33234 wxPyEndAllowThreads(__tstate);
33235 if (PyErr_Occurred()) SWIG_fail;
33236 }
33237 {
33238 resultobj = wxArrayString2PyList_helper(*result);
33239 }
33240 return resultobj;
33241 fail:
33242 return NULL;
33243 }
33244
33245
33246 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33247 PyObject *resultobj = 0;
33248 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
33249 wxString *arg2 = 0 ;
33250 void *argp1 = 0 ;
33251 int res1 = 0 ;
33252 bool temp2 = false ;
33253 PyObject * obj0 = 0 ;
33254 PyObject * obj1 = 0 ;
33255 char * kwnames[] = {
33256 (char *) "self",(char *) "filename", NULL
33257 };
33258
33259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
33260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
33261 if (!SWIG_IsOK(res1)) {
33262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
33263 }
33264 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
33265 {
33266 arg2 = wxString_in_helper(obj1);
33267 if (arg2 == NULL) SWIG_fail;
33268 temp2 = true;
33269 }
33270 {
33271 PyThreadState* __tstate = wxPyBeginAllowThreads();
33272 (arg1)->AddFile((wxString const &)*arg2);
33273 wxPyEndAllowThreads(__tstate);
33274 if (PyErr_Occurred()) SWIG_fail;
33275 }
33276 resultobj = SWIG_Py_Void();
33277 {
33278 if (temp2)
33279 delete arg2;
33280 }
33281 return resultobj;
33282 fail:
33283 {
33284 if (temp2)
33285 delete arg2;
33286 }
33287 return NULL;
33288 }
33289
33290
33291 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33292 PyObject *obj;
33293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33294 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
33295 return SWIG_Py_Void();
33296 }
33297
33298 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33299 return SWIG_Python_InitShadowInstance(args);
33300 }
33301
33302 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33303 PyObject *resultobj = 0;
33304 wxDataFormat *arg1 = 0 ;
33305 wxCustomDataObject *result = 0 ;
33306 void *argp1 = 0 ;
33307 int res1 = 0 ;
33308
33309 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
33311 if (!SWIG_IsOK(res1)) {
33312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33313 }
33314 if (!argp1) {
33315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
33316 }
33317 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
33318 {
33319 PyThreadState* __tstate = wxPyBeginAllowThreads();
33320 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
33321 wxPyEndAllowThreads(__tstate);
33322 if (PyErr_Occurred()) SWIG_fail;
33323 }
33324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33325 return resultobj;
33326 fail:
33327 return NULL;
33328 }
33329
33330
33331 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
33332 PyObject *resultobj = 0;
33333 wxString *arg1 = 0 ;
33334 wxCustomDataObject *result = 0 ;
33335 bool temp1 = false ;
33336
33337 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
33338 {
33339 arg1 = wxString_in_helper(swig_obj[0]);
33340 if (arg1 == NULL) SWIG_fail;
33341 temp1 = true;
33342 }
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33350 {
33351 if (temp1)
33352 delete arg1;
33353 }
33354 return resultobj;
33355 fail:
33356 {
33357 if (temp1)
33358 delete arg1;
33359 }
33360 return NULL;
33361 }
33362
33363
33364 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
33365 PyObject *resultobj = 0;
33366 wxCustomDataObject *result = 0 ;
33367
33368 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
33369 {
33370 PyThreadState* __tstate = wxPyBeginAllowThreads();
33371 result = (wxCustomDataObject *)new wxCustomDataObject();
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
33383 int argc;
33384 PyObject *argv[2];
33385
33386 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
33387 --argc;
33388 if (argc == 0) {
33389 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
33390 }
33391 if (argc == 1) {
33392 int _v = 0;
33393 {
33394 {
33395 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
33396 }
33397 }
33398 if (!_v) goto check_2;
33399 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
33400 }
33401 check_2:
33402
33403 if (argc == 1) {
33404 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
33405 }
33406
33407 fail:
33408 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
33409 return NULL;
33410 }
33411
33412
33413 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33414 PyObject *resultobj = 0;
33415 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33416 PyObject *arg2 = (PyObject *) 0 ;
33417 bool result;
33418 void *argp1 = 0 ;
33419 int res1 = 0 ;
33420 PyObject * obj0 = 0 ;
33421 PyObject * obj1 = 0 ;
33422 char * kwnames[] = {
33423 (char *) "self",(char *) "data", NULL
33424 };
33425
33426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33428 if (!SWIG_IsOK(res1)) {
33429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33430 }
33431 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33432 arg2 = obj1;
33433 {
33434 PyThreadState* __tstate = wxPyBeginAllowThreads();
33435 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
33436 wxPyEndAllowThreads(__tstate);
33437 if (PyErr_Occurred()) SWIG_fail;
33438 }
33439 {
33440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33441 }
33442 return resultobj;
33443 fail:
33444 return NULL;
33445 }
33446
33447
33448 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33449 PyObject *resultobj = 0;
33450 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33451 size_t result;
33452 void *argp1 = 0 ;
33453 int res1 = 0 ;
33454 PyObject *swig_obj[1] ;
33455
33456 if (!args) SWIG_fail;
33457 swig_obj[0] = args;
33458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33459 if (!SWIG_IsOK(res1)) {
33460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33461 }
33462 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33463 {
33464 PyThreadState* __tstate = wxPyBeginAllowThreads();
33465 result = (size_t)(arg1)->GetSize();
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
33470 return resultobj;
33471 fail:
33472 return NULL;
33473 }
33474
33475
33476 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33477 PyObject *resultobj = 0;
33478 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
33479 PyObject *result = 0 ;
33480 void *argp1 = 0 ;
33481 int res1 = 0 ;
33482 PyObject *swig_obj[1] ;
33483
33484 if (!args) SWIG_fail;
33485 swig_obj[0] = args;
33486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
33487 if (!SWIG_IsOK(res1)) {
33488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
33489 }
33490 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
33491 {
33492 PyThreadState* __tstate = wxPyBeginAllowThreads();
33493 result = (PyObject *)wxCustomDataObject_GetData(arg1);
33494 wxPyEndAllowThreads(__tstate);
33495 if (PyErr_Occurred()) SWIG_fail;
33496 }
33497 resultobj = result;
33498 return resultobj;
33499 fail:
33500 return NULL;
33501 }
33502
33503
33504 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33505 PyObject *obj;
33506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33507 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
33508 return SWIG_Py_Void();
33509 }
33510
33511 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33512 return SWIG_Python_InitShadowInstance(args);
33513 }
33514
33515 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33516 PyObject *resultobj = 0;
33517 wxString const &arg1_defvalue = wxPyEmptyString ;
33518 wxString *arg1 = (wxString *) &arg1_defvalue ;
33519 wxURLDataObject *result = 0 ;
33520 bool temp1 = false ;
33521 PyObject * obj0 = 0 ;
33522 char * kwnames[] = {
33523 (char *) "url", NULL
33524 };
33525
33526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_URLDataObject",kwnames,&obj0)) SWIG_fail;
33527 if (obj0) {
33528 {
33529 arg1 = wxString_in_helper(obj0);
33530 if (arg1 == NULL) SWIG_fail;
33531 temp1 = true;
33532 }
33533 }
33534 {
33535 PyThreadState* __tstate = wxPyBeginAllowThreads();
33536 result = (wxURLDataObject *)new wxURLDataObject((wxString const &)*arg1);
33537 wxPyEndAllowThreads(__tstate);
33538 if (PyErr_Occurred()) SWIG_fail;
33539 }
33540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
33541 {
33542 if (temp1)
33543 delete arg1;
33544 }
33545 return resultobj;
33546 fail:
33547 {
33548 if (temp1)
33549 delete arg1;
33550 }
33551 return NULL;
33552 }
33553
33554
33555 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33556 PyObject *resultobj = 0;
33557 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33558 wxString result;
33559 void *argp1 = 0 ;
33560 int res1 = 0 ;
33561 PyObject *swig_obj[1] ;
33562
33563 if (!args) SWIG_fail;
33564 swig_obj[0] = args;
33565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33566 if (!SWIG_IsOK(res1)) {
33567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33568 }
33569 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33570 {
33571 PyThreadState* __tstate = wxPyBeginAllowThreads();
33572 result = (arg1)->GetURL();
33573 wxPyEndAllowThreads(__tstate);
33574 if (PyErr_Occurred()) SWIG_fail;
33575 }
33576 {
33577 #if wxUSE_UNICODE
33578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33579 #else
33580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33581 #endif
33582 }
33583 return resultobj;
33584 fail:
33585 return NULL;
33586 }
33587
33588
33589 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33590 PyObject *resultobj = 0;
33591 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
33592 wxString *arg2 = 0 ;
33593 void *argp1 = 0 ;
33594 int res1 = 0 ;
33595 bool temp2 = false ;
33596 PyObject * obj0 = 0 ;
33597 PyObject * obj1 = 0 ;
33598 char * kwnames[] = {
33599 (char *) "self",(char *) "url", NULL
33600 };
33601
33602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
33603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
33604 if (!SWIG_IsOK(res1)) {
33605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
33606 }
33607 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
33608 {
33609 arg2 = wxString_in_helper(obj1);
33610 if (arg2 == NULL) SWIG_fail;
33611 temp2 = true;
33612 }
33613 {
33614 PyThreadState* __tstate = wxPyBeginAllowThreads();
33615 (arg1)->SetURL((wxString const &)*arg2);
33616 wxPyEndAllowThreads(__tstate);
33617 if (PyErr_Occurred()) SWIG_fail;
33618 }
33619 resultobj = SWIG_Py_Void();
33620 {
33621 if (temp2)
33622 delete arg2;
33623 }
33624 return resultobj;
33625 fail:
33626 {
33627 if (temp2)
33628 delete arg2;
33629 }
33630 return NULL;
33631 }
33632
33633
33634 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33635 PyObject *obj;
33636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33637 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
33638 return SWIG_Py_Void();
33639 }
33640
33641 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33642 return SWIG_Python_InitShadowInstance(args);
33643 }
33644
33645 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33646 PyObject *resultobj = 0;
33647 wxMetafileDataObject *result = 0 ;
33648
33649 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
33650 {
33651 PyThreadState* __tstate = wxPyBeginAllowThreads();
33652 result = (wxMetafileDataObject *)new wxMetafileDataObject();
33653 wxPyEndAllowThreads(__tstate);
33654 if (PyErr_Occurred()) SWIG_fail;
33655 }
33656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
33657 return resultobj;
33658 fail:
33659 return NULL;
33660 }
33661
33662
33663 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33664 PyObject *obj;
33665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33666 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
33667 return SWIG_Py_Void();
33668 }
33669
33670 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33671 return SWIG_Python_InitShadowInstance(args);
33672 }
33673
33674 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33675 PyObject *resultobj = 0;
33676 wxDragResult arg1 ;
33677 bool result;
33678 int val1 ;
33679 int ecode1 = 0 ;
33680 PyObject * obj0 = 0 ;
33681 char * kwnames[] = {
33682 (char *) "res", NULL
33683 };
33684
33685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
33686 ecode1 = SWIG_AsVal_int(obj0, &val1);
33687 if (!SWIG_IsOK(ecode1)) {
33688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
33689 }
33690 arg1 = static_cast< wxDragResult >(val1);
33691 {
33692 PyThreadState* __tstate = wxPyBeginAllowThreads();
33693 result = (bool)wxIsDragResultOk(arg1);
33694 wxPyEndAllowThreads(__tstate);
33695 if (PyErr_Occurred()) SWIG_fail;
33696 }
33697 {
33698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33699 }
33700 return resultobj;
33701 fail:
33702 return NULL;
33703 }
33704
33705
33706 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33707 PyObject *resultobj = 0;
33708 wxWindow *arg1 = (wxWindow *) 0 ;
33709 wxIcon const &arg2_defvalue = wxNullIcon ;
33710 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
33711 wxIcon const &arg3_defvalue = wxNullIcon ;
33712 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
33713 wxIcon const &arg4_defvalue = wxNullIcon ;
33714 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
33715 wxPyDropSource *result = 0 ;
33716 void *argp1 = 0 ;
33717 int res1 = 0 ;
33718 void *argp2 = 0 ;
33719 int res2 = 0 ;
33720 void *argp3 = 0 ;
33721 int res3 = 0 ;
33722 void *argp4 = 0 ;
33723 int res4 = 0 ;
33724 PyObject * obj0 = 0 ;
33725 PyObject * obj1 = 0 ;
33726 PyObject * obj2 = 0 ;
33727 PyObject * obj3 = 0 ;
33728 char * kwnames[] = {
33729 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
33730 };
33731
33732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33734 if (!SWIG_IsOK(res1)) {
33735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
33736 }
33737 arg1 = reinterpret_cast< wxWindow * >(argp1);
33738 if (obj1) {
33739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
33740 if (!SWIG_IsOK(res2)) {
33741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33742 }
33743 if (!argp2) {
33744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
33745 }
33746 arg2 = reinterpret_cast< wxIcon * >(argp2);
33747 }
33748 if (obj2) {
33749 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
33750 if (!SWIG_IsOK(res3)) {
33751 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33752 }
33753 if (!argp3) {
33754 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
33755 }
33756 arg3 = reinterpret_cast< wxIcon * >(argp3);
33757 }
33758 if (obj3) {
33759 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
33760 if (!SWIG_IsOK(res4)) {
33761 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33762 }
33763 if (!argp4) {
33764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
33765 }
33766 arg4 = reinterpret_cast< wxIcon * >(argp4);
33767 }
33768 {
33769 PyThreadState* __tstate = wxPyBeginAllowThreads();
33770 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
33771 wxPyEndAllowThreads(__tstate);
33772 if (PyErr_Occurred()) SWIG_fail;
33773 }
33774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
33775 return resultobj;
33776 fail:
33777 return NULL;
33778 }
33779
33780
33781 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33782 PyObject *resultobj = 0;
33783 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33784 PyObject *arg2 = (PyObject *) 0 ;
33785 PyObject *arg3 = (PyObject *) 0 ;
33786 int arg4 ;
33787 void *argp1 = 0 ;
33788 int res1 = 0 ;
33789 int val4 ;
33790 int ecode4 = 0 ;
33791 PyObject * obj0 = 0 ;
33792 PyObject * obj1 = 0 ;
33793 PyObject * obj2 = 0 ;
33794 PyObject * obj3 = 0 ;
33795 char * kwnames[] = {
33796 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33797 };
33798
33799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33801 if (!SWIG_IsOK(res1)) {
33802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33803 }
33804 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33805 arg2 = obj1;
33806 arg3 = obj2;
33807 ecode4 = SWIG_AsVal_int(obj3, &val4);
33808 if (!SWIG_IsOK(ecode4)) {
33809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
33810 }
33811 arg4 = static_cast< int >(val4);
33812 {
33813 PyThreadState* __tstate = wxPyBeginAllowThreads();
33814 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33815 wxPyEndAllowThreads(__tstate);
33816 if (PyErr_Occurred()) SWIG_fail;
33817 }
33818 resultobj = SWIG_Py_Void();
33819 return resultobj;
33820 fail:
33821 return NULL;
33822 }
33823
33824
33825 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33826 PyObject *resultobj = 0;
33827 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33828 void *argp1 = 0 ;
33829 int res1 = 0 ;
33830 PyObject *swig_obj[1] ;
33831
33832 if (!args) SWIG_fail;
33833 swig_obj[0] = args;
33834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
33835 if (!SWIG_IsOK(res1)) {
33836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33837 }
33838 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33839 {
33840 PyThreadState* __tstate = wxPyBeginAllowThreads();
33841 delete arg1;
33842
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 resultobj = SWIG_Py_Void();
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33854 PyObject *resultobj = 0;
33855 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33856 wxDataObject *arg2 = 0 ;
33857 void *argp1 = 0 ;
33858 int res1 = 0 ;
33859 void *argp2 = 0 ;
33860 int res2 = 0 ;
33861 PyObject * obj0 = 0 ;
33862 PyObject * obj1 = 0 ;
33863 char * kwnames[] = {
33864 (char *) "self",(char *) "data", NULL
33865 };
33866
33867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
33868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33869 if (!SWIG_IsOK(res1)) {
33870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33871 }
33872 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
33874 if (!SWIG_IsOK(res2)) {
33875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33876 }
33877 if (!argp2) {
33878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
33879 }
33880 arg2 = reinterpret_cast< wxDataObject * >(argp2);
33881 {
33882 PyThreadState* __tstate = wxPyBeginAllowThreads();
33883 (arg1)->SetData(*arg2);
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 resultobj = SWIG_Py_Void();
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33895 PyObject *resultobj = 0;
33896 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33897 wxDataObject *result = 0 ;
33898 void *argp1 = 0 ;
33899 int res1 = 0 ;
33900 PyObject *swig_obj[1] ;
33901
33902 if (!args) SWIG_fail;
33903 swig_obj[0] = args;
33904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33905 if (!SWIG_IsOK(res1)) {
33906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33907 }
33908 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33909 {
33910 PyThreadState* __tstate = wxPyBeginAllowThreads();
33911 result = (wxDataObject *)(arg1)->GetDataObject();
33912 wxPyEndAllowThreads(__tstate);
33913 if (PyErr_Occurred()) SWIG_fail;
33914 }
33915 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33916 return resultobj;
33917 fail:
33918 return NULL;
33919 }
33920
33921
33922 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33923 PyObject *resultobj = 0;
33924 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33925 wxDragResult arg2 ;
33926 wxCursor *arg3 = 0 ;
33927 void *argp1 = 0 ;
33928 int res1 = 0 ;
33929 int val2 ;
33930 int ecode2 = 0 ;
33931 void *argp3 = 0 ;
33932 int res3 = 0 ;
33933 PyObject * obj0 = 0 ;
33934 PyObject * obj1 = 0 ;
33935 PyObject * obj2 = 0 ;
33936 char * kwnames[] = {
33937 (char *) "self",(char *) "res",(char *) "cursor", NULL
33938 };
33939
33940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33942 if (!SWIG_IsOK(res1)) {
33943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33944 }
33945 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33946 ecode2 = SWIG_AsVal_int(obj1, &val2);
33947 if (!SWIG_IsOK(ecode2)) {
33948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
33949 }
33950 arg2 = static_cast< wxDragResult >(val2);
33951 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
33952 if (!SWIG_IsOK(res3)) {
33953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33954 }
33955 if (!argp3) {
33956 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
33957 }
33958 arg3 = reinterpret_cast< wxCursor * >(argp3);
33959 {
33960 PyThreadState* __tstate = wxPyBeginAllowThreads();
33961 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
33962 wxPyEndAllowThreads(__tstate);
33963 if (PyErr_Occurred()) SWIG_fail;
33964 }
33965 resultobj = SWIG_Py_Void();
33966 return resultobj;
33967 fail:
33968 return NULL;
33969 }
33970
33971
33972 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33973 PyObject *resultobj = 0;
33974 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
33975 int arg2 = (int) wxDrag_CopyOnly ;
33976 wxDragResult result;
33977 void *argp1 = 0 ;
33978 int res1 = 0 ;
33979 int val2 ;
33980 int ecode2 = 0 ;
33981 PyObject * obj0 = 0 ;
33982 PyObject * obj1 = 0 ;
33983 char * kwnames[] = {
33984 (char *) "self",(char *) "flags", NULL
33985 };
33986
33987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
33988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
33989 if (!SWIG_IsOK(res1)) {
33990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
33991 }
33992 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
33993 if (obj1) {
33994 ecode2 = SWIG_AsVal_int(obj1, &val2);
33995 if (!SWIG_IsOK(ecode2)) {
33996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
33997 }
33998 arg2 = static_cast< int >(val2);
33999 }
34000 {
34001 PyThreadState* __tstate = wxPyBeginAllowThreads();
34002 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
34003 wxPyEndAllowThreads(__tstate);
34004 if (PyErr_Occurred()) SWIG_fail;
34005 }
34006 resultobj = SWIG_From_int(static_cast< int >(result));
34007 return resultobj;
34008 fail:
34009 return NULL;
34010 }
34011
34012
34013 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34014 PyObject *resultobj = 0;
34015 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
34016 wxDragResult arg2 ;
34017 bool result;
34018 void *argp1 = 0 ;
34019 int res1 = 0 ;
34020 int val2 ;
34021 int ecode2 = 0 ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 char * kwnames[] = {
34025 (char *) "self",(char *) "effect", NULL
34026 };
34027
34028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
34029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
34032 }
34033 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
34034 ecode2 = SWIG_AsVal_int(obj1, &val2);
34035 if (!SWIG_IsOK(ecode2)) {
34036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
34037 }
34038 arg2 = static_cast< wxDragResult >(val2);
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 result = (bool)(arg1)->GiveFeedback(arg2);
34042 wxPyEndAllowThreads(__tstate);
34043 if (PyErr_Occurred()) SWIG_fail;
34044 }
34045 {
34046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34047 }
34048 return resultobj;
34049 fail:
34050 return NULL;
34051 }
34052
34053
34054 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34055 PyObject *obj;
34056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34057 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
34058 return SWIG_Py_Void();
34059 }
34060
34061 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34062 return SWIG_Python_InitShadowInstance(args);
34063 }
34064
34065 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34066 PyObject *resultobj = 0;
34067 wxDataObject *arg1 = (wxDataObject *) NULL ;
34068 wxPyDropTarget *result = 0 ;
34069 int res1 = 0 ;
34070 PyObject * obj0 = 0 ;
34071 char * kwnames[] = {
34072 (char *) "dataObject", NULL
34073 };
34074
34075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
34076 if (obj0) {
34077 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34078 if (!SWIG_IsOK(res1)) {
34079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
34080 }
34081 }
34082 {
34083 PyThreadState* __tstate = wxPyBeginAllowThreads();
34084 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
34085 wxPyEndAllowThreads(__tstate);
34086 if (PyErr_Occurred()) SWIG_fail;
34087 }
34088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
34089 return resultobj;
34090 fail:
34091 return NULL;
34092 }
34093
34094
34095 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34096 PyObject *resultobj = 0;
34097 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34098 PyObject *arg2 = (PyObject *) 0 ;
34099 PyObject *arg3 = (PyObject *) 0 ;
34100 void *argp1 = 0 ;
34101 int res1 = 0 ;
34102 PyObject * obj0 = 0 ;
34103 PyObject * obj1 = 0 ;
34104 PyObject * obj2 = 0 ;
34105 char * kwnames[] = {
34106 (char *) "self",(char *) "self",(char *) "_class", NULL
34107 };
34108
34109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34111 if (!SWIG_IsOK(res1)) {
34112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34113 }
34114 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34115 arg2 = obj1;
34116 arg3 = obj2;
34117 {
34118 PyThreadState* __tstate = wxPyBeginAllowThreads();
34119 (arg1)->_setCallbackInfo(arg2,arg3);
34120 wxPyEndAllowThreads(__tstate);
34121 if (PyErr_Occurred()) SWIG_fail;
34122 }
34123 resultobj = SWIG_Py_Void();
34124 return resultobj;
34125 fail:
34126 return NULL;
34127 }
34128
34129
34130 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34131 PyObject *resultobj = 0;
34132 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34133 void *argp1 = 0 ;
34134 int res1 = 0 ;
34135 PyObject *swig_obj[1] ;
34136
34137 if (!args) SWIG_fail;
34138 swig_obj[0] = args;
34139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
34140 if (!SWIG_IsOK(res1)) {
34141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34142 }
34143 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34144 {
34145 PyThreadState* __tstate = wxPyBeginAllowThreads();
34146 delete arg1;
34147
34148 wxPyEndAllowThreads(__tstate);
34149 if (PyErr_Occurred()) SWIG_fail;
34150 }
34151 resultobj = SWIG_Py_Void();
34152 return resultobj;
34153 fail:
34154 return NULL;
34155 }
34156
34157
34158 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34159 PyObject *resultobj = 0;
34160 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34161 wxDataObject *result = 0 ;
34162 void *argp1 = 0 ;
34163 int res1 = 0 ;
34164 PyObject *swig_obj[1] ;
34165
34166 if (!args) SWIG_fail;
34167 swig_obj[0] = args;
34168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34169 if (!SWIG_IsOK(res1)) {
34170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34171 }
34172 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34173 {
34174 PyThreadState* __tstate = wxPyBeginAllowThreads();
34175 result = (wxDataObject *)(arg1)->GetDataObject();
34176 wxPyEndAllowThreads(__tstate);
34177 if (PyErr_Occurred()) SWIG_fail;
34178 }
34179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
34180 return resultobj;
34181 fail:
34182 return NULL;
34183 }
34184
34185
34186 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34187 PyObject *resultobj = 0;
34188 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34189 wxDataObject *arg2 = (wxDataObject *) 0 ;
34190 void *argp1 = 0 ;
34191 int res1 = 0 ;
34192 int res2 = 0 ;
34193 PyObject * obj0 = 0 ;
34194 PyObject * obj1 = 0 ;
34195 char * kwnames[] = {
34196 (char *) "self",(char *) "dataObject", NULL
34197 };
34198
34199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
34200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34201 if (!SWIG_IsOK(res1)) {
34202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34203 }
34204 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34205 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34206 if (!SWIG_IsOK(res2)) {
34207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
34208 }
34209 {
34210 PyThreadState* __tstate = wxPyBeginAllowThreads();
34211 (arg1)->SetDataObject(arg2);
34212 wxPyEndAllowThreads(__tstate);
34213 if (PyErr_Occurred()) SWIG_fail;
34214 }
34215 resultobj = SWIG_Py_Void();
34216 return resultobj;
34217 fail:
34218 return NULL;
34219 }
34220
34221
34222 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34223 PyObject *resultobj = 0;
34224 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34225 int arg2 ;
34226 int arg3 ;
34227 wxDragResult arg4 ;
34228 wxDragResult result;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 int val2 ;
34232 int ecode2 = 0 ;
34233 int val3 ;
34234 int ecode3 = 0 ;
34235 int val4 ;
34236 int ecode4 = 0 ;
34237 PyObject * obj0 = 0 ;
34238 PyObject * obj1 = 0 ;
34239 PyObject * obj2 = 0 ;
34240 PyObject * obj3 = 0 ;
34241 char * kwnames[] = {
34242 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34243 };
34244
34245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34247 if (!SWIG_IsOK(res1)) {
34248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34249 }
34250 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34251 ecode2 = SWIG_AsVal_int(obj1, &val2);
34252 if (!SWIG_IsOK(ecode2)) {
34253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34254 }
34255 arg2 = static_cast< int >(val2);
34256 ecode3 = SWIG_AsVal_int(obj2, &val3);
34257 if (!SWIG_IsOK(ecode3)) {
34258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34259 }
34260 arg3 = static_cast< int >(val3);
34261 ecode4 = SWIG_AsVal_int(obj3, &val4);
34262 if (!SWIG_IsOK(ecode4)) {
34263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34264 }
34265 arg4 = static_cast< wxDragResult >(val4);
34266 {
34267 PyThreadState* __tstate = wxPyBeginAllowThreads();
34268 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34269 wxPyEndAllowThreads(__tstate);
34270 if (PyErr_Occurred()) SWIG_fail;
34271 }
34272 resultobj = SWIG_From_int(static_cast< int >(result));
34273 return resultobj;
34274 fail:
34275 return NULL;
34276 }
34277
34278
34279 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34280 PyObject *resultobj = 0;
34281 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34282 int arg2 ;
34283 int arg3 ;
34284 wxDragResult arg4 ;
34285 wxDragResult result;
34286 void *argp1 = 0 ;
34287 int res1 = 0 ;
34288 int val2 ;
34289 int ecode2 = 0 ;
34290 int val3 ;
34291 int ecode3 = 0 ;
34292 int val4 ;
34293 int ecode4 = 0 ;
34294 PyObject * obj0 = 0 ;
34295 PyObject * obj1 = 0 ;
34296 PyObject * obj2 = 0 ;
34297 PyObject * obj3 = 0 ;
34298 char * kwnames[] = {
34299 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34300 };
34301
34302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34304 if (!SWIG_IsOK(res1)) {
34305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34306 }
34307 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34308 ecode2 = SWIG_AsVal_int(obj1, &val2);
34309 if (!SWIG_IsOK(ecode2)) {
34310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34311 }
34312 arg2 = static_cast< int >(val2);
34313 ecode3 = SWIG_AsVal_int(obj2, &val3);
34314 if (!SWIG_IsOK(ecode3)) {
34315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34316 }
34317 arg3 = static_cast< int >(val3);
34318 ecode4 = SWIG_AsVal_int(obj3, &val4);
34319 if (!SWIG_IsOK(ecode4)) {
34320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34321 }
34322 arg4 = static_cast< wxDragResult >(val4);
34323 {
34324 PyThreadState* __tstate = wxPyBeginAllowThreads();
34325 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34326 wxPyEndAllowThreads(__tstate);
34327 if (PyErr_Occurred()) SWIG_fail;
34328 }
34329 resultobj = SWIG_From_int(static_cast< int >(result));
34330 return resultobj;
34331 fail:
34332 return NULL;
34333 }
34334
34335
34336 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34337 PyObject *resultobj = 0;
34338 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34339 void *argp1 = 0 ;
34340 int res1 = 0 ;
34341 PyObject *swig_obj[1] ;
34342
34343 if (!args) SWIG_fail;
34344 swig_obj[0] = args;
34345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34346 if (!SWIG_IsOK(res1)) {
34347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34348 }
34349 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34350 {
34351 PyThreadState* __tstate = wxPyBeginAllowThreads();
34352 (arg1)->OnLeave();
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 resultobj = SWIG_Py_Void();
34357 return resultobj;
34358 fail:
34359 return NULL;
34360 }
34361
34362
34363 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34364 PyObject *resultobj = 0;
34365 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34366 int arg2 ;
34367 int arg3 ;
34368 bool result;
34369 void *argp1 = 0 ;
34370 int res1 = 0 ;
34371 int val2 ;
34372 int ecode2 = 0 ;
34373 int val3 ;
34374 int ecode3 = 0 ;
34375 PyObject * obj0 = 0 ;
34376 PyObject * obj1 = 0 ;
34377 PyObject * obj2 = 0 ;
34378 char * kwnames[] = {
34379 (char *) "self",(char *) "x",(char *) "y", NULL
34380 };
34381
34382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34384 if (!SWIG_IsOK(res1)) {
34385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34386 }
34387 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34388 ecode2 = SWIG_AsVal_int(obj1, &val2);
34389 if (!SWIG_IsOK(ecode2)) {
34390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34391 }
34392 arg2 = static_cast< int >(val2);
34393 ecode3 = SWIG_AsVal_int(obj2, &val3);
34394 if (!SWIG_IsOK(ecode3)) {
34395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34396 }
34397 arg3 = static_cast< int >(val3);
34398 {
34399 PyThreadState* __tstate = wxPyBeginAllowThreads();
34400 result = (bool)(arg1)->OnDrop(arg2,arg3);
34401 wxPyEndAllowThreads(__tstate);
34402 if (PyErr_Occurred()) SWIG_fail;
34403 }
34404 {
34405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34406 }
34407 return resultobj;
34408 fail:
34409 return NULL;
34410 }
34411
34412
34413 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34414 PyObject *resultobj = 0;
34415 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34416 bool result;
34417 void *argp1 = 0 ;
34418 int res1 = 0 ;
34419 PyObject *swig_obj[1] ;
34420
34421 if (!args) SWIG_fail;
34422 swig_obj[0] = args;
34423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34424 if (!SWIG_IsOK(res1)) {
34425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34426 }
34427 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34428 {
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 result = (bool)(arg1)->GetData();
34431 wxPyEndAllowThreads(__tstate);
34432 if (PyErr_Occurred()) SWIG_fail;
34433 }
34434 {
34435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34436 }
34437 return resultobj;
34438 fail:
34439 return NULL;
34440 }
34441
34442
34443 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34444 PyObject *resultobj = 0;
34445 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34446 wxDragResult arg2 ;
34447 void *argp1 = 0 ;
34448 int res1 = 0 ;
34449 int val2 ;
34450 int ecode2 = 0 ;
34451 PyObject * obj0 = 0 ;
34452 PyObject * obj1 = 0 ;
34453 char * kwnames[] = {
34454 (char *) "self",(char *) "action", NULL
34455 };
34456
34457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
34458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34459 if (!SWIG_IsOK(res1)) {
34460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34461 }
34462 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34463 ecode2 = SWIG_AsVal_int(obj1, &val2);
34464 if (!SWIG_IsOK(ecode2)) {
34465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
34466 }
34467 arg2 = static_cast< wxDragResult >(val2);
34468 {
34469 PyThreadState* __tstate = wxPyBeginAllowThreads();
34470 (arg1)->SetDefaultAction(arg2);
34471 wxPyEndAllowThreads(__tstate);
34472 if (PyErr_Occurred()) SWIG_fail;
34473 }
34474 resultobj = SWIG_Py_Void();
34475 return resultobj;
34476 fail:
34477 return NULL;
34478 }
34479
34480
34481 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34482 PyObject *resultobj = 0;
34483 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
34484 wxDragResult result;
34485 void *argp1 = 0 ;
34486 int res1 = 0 ;
34487 PyObject *swig_obj[1] ;
34488
34489 if (!args) SWIG_fail;
34490 swig_obj[0] = args;
34491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
34492 if (!SWIG_IsOK(res1)) {
34493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
34494 }
34495 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
34496 {
34497 PyThreadState* __tstate = wxPyBeginAllowThreads();
34498 result = (wxDragResult)(arg1)->GetDefaultAction();
34499 wxPyEndAllowThreads(__tstate);
34500 if (PyErr_Occurred()) SWIG_fail;
34501 }
34502 resultobj = SWIG_From_int(static_cast< int >(result));
34503 return resultobj;
34504 fail:
34505 return NULL;
34506 }
34507
34508
34509 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34510 PyObject *obj;
34511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34512 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
34513 return SWIG_Py_Void();
34514 }
34515
34516 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34517 return SWIG_Python_InitShadowInstance(args);
34518 }
34519
34520 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34521 PyObject *resultobj = 0;
34522 wxPyTextDropTarget *result = 0 ;
34523
34524 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
34525 {
34526 PyThreadState* __tstate = wxPyBeginAllowThreads();
34527 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
34528 wxPyEndAllowThreads(__tstate);
34529 if (PyErr_Occurred()) SWIG_fail;
34530 }
34531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
34532 return resultobj;
34533 fail:
34534 return NULL;
34535 }
34536
34537
34538 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34539 PyObject *resultobj = 0;
34540 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34541 PyObject *arg2 = (PyObject *) 0 ;
34542 PyObject *arg3 = (PyObject *) 0 ;
34543 void *argp1 = 0 ;
34544 int res1 = 0 ;
34545 PyObject * obj0 = 0 ;
34546 PyObject * obj1 = 0 ;
34547 PyObject * obj2 = 0 ;
34548 char * kwnames[] = {
34549 (char *) "self",(char *) "self",(char *) "_class", NULL
34550 };
34551
34552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34554 if (!SWIG_IsOK(res1)) {
34555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34556 }
34557 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34558 arg2 = obj1;
34559 arg3 = obj2;
34560 {
34561 PyThreadState* __tstate = wxPyBeginAllowThreads();
34562 (arg1)->_setCallbackInfo(arg2,arg3);
34563 wxPyEndAllowThreads(__tstate);
34564 if (PyErr_Occurred()) SWIG_fail;
34565 }
34566 resultobj = SWIG_Py_Void();
34567 return resultobj;
34568 fail:
34569 return NULL;
34570 }
34571
34572
34573 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34574 PyObject *resultobj = 0;
34575 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34576 int arg2 ;
34577 int arg3 ;
34578 wxString *arg4 = 0 ;
34579 bool result;
34580 void *argp1 = 0 ;
34581 int res1 = 0 ;
34582 int val2 ;
34583 int ecode2 = 0 ;
34584 int val3 ;
34585 int ecode3 = 0 ;
34586 bool temp4 = false ;
34587 PyObject * obj0 = 0 ;
34588 PyObject * obj1 = 0 ;
34589 PyObject * obj2 = 0 ;
34590 PyObject * obj3 = 0 ;
34591 char * kwnames[] = {
34592 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
34593 };
34594
34595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34597 if (!SWIG_IsOK(res1)) {
34598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34599 }
34600 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34601 ecode2 = SWIG_AsVal_int(obj1, &val2);
34602 if (!SWIG_IsOK(ecode2)) {
34603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
34604 }
34605 arg2 = static_cast< int >(val2);
34606 ecode3 = SWIG_AsVal_int(obj2, &val3);
34607 if (!SWIG_IsOK(ecode3)) {
34608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
34609 }
34610 arg3 = static_cast< int >(val3);
34611 {
34612 arg4 = wxString_in_helper(obj3);
34613 if (arg4 == NULL) SWIG_fail;
34614 temp4 = true;
34615 }
34616 {
34617 PyThreadState* __tstate = wxPyBeginAllowThreads();
34618 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
34619 wxPyEndAllowThreads(__tstate);
34620 if (PyErr_Occurred()) SWIG_fail;
34621 }
34622 {
34623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34624 }
34625 {
34626 if (temp4)
34627 delete arg4;
34628 }
34629 return resultobj;
34630 fail:
34631 {
34632 if (temp4)
34633 delete arg4;
34634 }
34635 return NULL;
34636 }
34637
34638
34639 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34640 PyObject *resultobj = 0;
34641 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34642 int arg2 ;
34643 int arg3 ;
34644 wxDragResult arg4 ;
34645 wxDragResult result;
34646 void *argp1 = 0 ;
34647 int res1 = 0 ;
34648 int val2 ;
34649 int ecode2 = 0 ;
34650 int val3 ;
34651 int ecode3 = 0 ;
34652 int val4 ;
34653 int ecode4 = 0 ;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 PyObject * obj2 = 0 ;
34657 PyObject * obj3 = 0 ;
34658 char * kwnames[] = {
34659 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34660 };
34661
34662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34664 if (!SWIG_IsOK(res1)) {
34665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34666 }
34667 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34668 ecode2 = SWIG_AsVal_int(obj1, &val2);
34669 if (!SWIG_IsOK(ecode2)) {
34670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
34671 }
34672 arg2 = static_cast< int >(val2);
34673 ecode3 = SWIG_AsVal_int(obj2, &val3);
34674 if (!SWIG_IsOK(ecode3)) {
34675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
34676 }
34677 arg3 = static_cast< int >(val3);
34678 ecode4 = SWIG_AsVal_int(obj3, &val4);
34679 if (!SWIG_IsOK(ecode4)) {
34680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
34681 }
34682 arg4 = static_cast< wxDragResult >(val4);
34683 {
34684 PyThreadState* __tstate = wxPyBeginAllowThreads();
34685 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
34686 wxPyEndAllowThreads(__tstate);
34687 if (PyErr_Occurred()) SWIG_fail;
34688 }
34689 resultobj = SWIG_From_int(static_cast< int >(result));
34690 return resultobj;
34691 fail:
34692 return NULL;
34693 }
34694
34695
34696 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34697 PyObject *resultobj = 0;
34698 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34699 int arg2 ;
34700 int arg3 ;
34701 wxDragResult arg4 ;
34702 wxDragResult result;
34703 void *argp1 = 0 ;
34704 int res1 = 0 ;
34705 int val2 ;
34706 int ecode2 = 0 ;
34707 int val3 ;
34708 int ecode3 = 0 ;
34709 int val4 ;
34710 int ecode4 = 0 ;
34711 PyObject * obj0 = 0 ;
34712 PyObject * obj1 = 0 ;
34713 PyObject * obj2 = 0 ;
34714 PyObject * obj3 = 0 ;
34715 char * kwnames[] = {
34716 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34717 };
34718
34719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34721 if (!SWIG_IsOK(res1)) {
34722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34723 }
34724 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34725 ecode2 = SWIG_AsVal_int(obj1, &val2);
34726 if (!SWIG_IsOK(ecode2)) {
34727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
34728 }
34729 arg2 = static_cast< int >(val2);
34730 ecode3 = SWIG_AsVal_int(obj2, &val3);
34731 if (!SWIG_IsOK(ecode3)) {
34732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
34733 }
34734 arg3 = static_cast< int >(val3);
34735 ecode4 = SWIG_AsVal_int(obj3, &val4);
34736 if (!SWIG_IsOK(ecode4)) {
34737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
34738 }
34739 arg4 = static_cast< wxDragResult >(val4);
34740 {
34741 PyThreadState* __tstate = wxPyBeginAllowThreads();
34742 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
34743 wxPyEndAllowThreads(__tstate);
34744 if (PyErr_Occurred()) SWIG_fail;
34745 }
34746 resultobj = SWIG_From_int(static_cast< int >(result));
34747 return resultobj;
34748 fail:
34749 return NULL;
34750 }
34751
34752
34753 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34754 PyObject *resultobj = 0;
34755 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34756 void *argp1 = 0 ;
34757 int res1 = 0 ;
34758 PyObject *swig_obj[1] ;
34759
34760 if (!args) SWIG_fail;
34761 swig_obj[0] = args;
34762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34763 if (!SWIG_IsOK(res1)) {
34764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34765 }
34766 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 (arg1)->OnLeave();
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 resultobj = SWIG_Py_Void();
34774 return resultobj;
34775 fail:
34776 return NULL;
34777 }
34778
34779
34780 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34781 PyObject *resultobj = 0;
34782 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34783 int arg2 ;
34784 int arg3 ;
34785 bool result;
34786 void *argp1 = 0 ;
34787 int res1 = 0 ;
34788 int val2 ;
34789 int ecode2 = 0 ;
34790 int val3 ;
34791 int ecode3 = 0 ;
34792 PyObject * obj0 = 0 ;
34793 PyObject * obj1 = 0 ;
34794 PyObject * obj2 = 0 ;
34795 char * kwnames[] = {
34796 (char *) "self",(char *) "x",(char *) "y", NULL
34797 };
34798
34799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34803 }
34804 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34805 ecode2 = SWIG_AsVal_int(obj1, &val2);
34806 if (!SWIG_IsOK(ecode2)) {
34807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34808 }
34809 arg2 = static_cast< int >(val2);
34810 ecode3 = SWIG_AsVal_int(obj2, &val3);
34811 if (!SWIG_IsOK(ecode3)) {
34812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34813 }
34814 arg3 = static_cast< int >(val3);
34815 {
34816 PyThreadState* __tstate = wxPyBeginAllowThreads();
34817 result = (bool)(arg1)->OnDrop(arg2,arg3);
34818 wxPyEndAllowThreads(__tstate);
34819 if (PyErr_Occurred()) SWIG_fail;
34820 }
34821 {
34822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34823 }
34824 return resultobj;
34825 fail:
34826 return NULL;
34827 }
34828
34829
34830 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34831 PyObject *resultobj = 0;
34832 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
34833 int arg2 ;
34834 int arg3 ;
34835 wxDragResult arg4 ;
34836 wxDragResult result;
34837 void *argp1 = 0 ;
34838 int res1 = 0 ;
34839 int val2 ;
34840 int ecode2 = 0 ;
34841 int val3 ;
34842 int ecode3 = 0 ;
34843 int val4 ;
34844 int ecode4 = 0 ;
34845 PyObject * obj0 = 0 ;
34846 PyObject * obj1 = 0 ;
34847 PyObject * obj2 = 0 ;
34848 PyObject * obj3 = 0 ;
34849 char * kwnames[] = {
34850 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34851 };
34852
34853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
34855 if (!SWIG_IsOK(res1)) {
34856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
34857 }
34858 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
34859 ecode2 = SWIG_AsVal_int(obj1, &val2);
34860 if (!SWIG_IsOK(ecode2)) {
34861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34862 }
34863 arg2 = static_cast< int >(val2);
34864 ecode3 = SWIG_AsVal_int(obj2, &val3);
34865 if (!SWIG_IsOK(ecode3)) {
34866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34867 }
34868 arg3 = static_cast< int >(val3);
34869 ecode4 = SWIG_AsVal_int(obj3, &val4);
34870 if (!SWIG_IsOK(ecode4)) {
34871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34872 }
34873 arg4 = static_cast< wxDragResult >(val4);
34874 {
34875 PyThreadState* __tstate = wxPyBeginAllowThreads();
34876 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34877 wxPyEndAllowThreads(__tstate);
34878 if (PyErr_Occurred()) SWIG_fail;
34879 }
34880 resultobj = SWIG_From_int(static_cast< int >(result));
34881 return resultobj;
34882 fail:
34883 return NULL;
34884 }
34885
34886
34887 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34888 PyObject *obj;
34889 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34890 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
34891 return SWIG_Py_Void();
34892 }
34893
34894 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34895 return SWIG_Python_InitShadowInstance(args);
34896 }
34897
34898 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34899 PyObject *resultobj = 0;
34900 wxPyFileDropTarget *result = 0 ;
34901
34902 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
34903 {
34904 PyThreadState* __tstate = wxPyBeginAllowThreads();
34905 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
34906 wxPyEndAllowThreads(__tstate);
34907 if (PyErr_Occurred()) SWIG_fail;
34908 }
34909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
34910 return resultobj;
34911 fail:
34912 return NULL;
34913 }
34914
34915
34916 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34917 PyObject *resultobj = 0;
34918 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34919 PyObject *arg2 = (PyObject *) 0 ;
34920 PyObject *arg3 = (PyObject *) 0 ;
34921 void *argp1 = 0 ;
34922 int res1 = 0 ;
34923 PyObject * obj0 = 0 ;
34924 PyObject * obj1 = 0 ;
34925 PyObject * obj2 = 0 ;
34926 char * kwnames[] = {
34927 (char *) "self",(char *) "self",(char *) "_class", NULL
34928 };
34929
34930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34932 if (!SWIG_IsOK(res1)) {
34933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34934 }
34935 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34936 arg2 = obj1;
34937 arg3 = obj2;
34938 {
34939 PyThreadState* __tstate = wxPyBeginAllowThreads();
34940 (arg1)->_setCallbackInfo(arg2,arg3);
34941 wxPyEndAllowThreads(__tstate);
34942 if (PyErr_Occurred()) SWIG_fail;
34943 }
34944 resultobj = SWIG_Py_Void();
34945 return resultobj;
34946 fail:
34947 return NULL;
34948 }
34949
34950
34951 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34952 PyObject *resultobj = 0;
34953 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34954 int arg2 ;
34955 int arg3 ;
34956 wxArrayString *arg4 = 0 ;
34957 bool result;
34958 void *argp1 = 0 ;
34959 int res1 = 0 ;
34960 int val2 ;
34961 int ecode2 = 0 ;
34962 int val3 ;
34963 int ecode3 = 0 ;
34964 bool temp4 = false ;
34965 PyObject * obj0 = 0 ;
34966 PyObject * obj1 = 0 ;
34967 PyObject * obj2 = 0 ;
34968 PyObject * obj3 = 0 ;
34969 char * kwnames[] = {
34970 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
34971 };
34972
34973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34975 if (!SWIG_IsOK(res1)) {
34976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34977 }
34978 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34979 ecode2 = SWIG_AsVal_int(obj1, &val2);
34980 if (!SWIG_IsOK(ecode2)) {
34981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
34982 }
34983 arg2 = static_cast< int >(val2);
34984 ecode3 = SWIG_AsVal_int(obj2, &val3);
34985 if (!SWIG_IsOK(ecode3)) {
34986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
34987 }
34988 arg3 = static_cast< int >(val3);
34989 {
34990 if (! PySequence_Check(obj3)) {
34991 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
34992 SWIG_fail;
34993 }
34994 arg4 = new wxArrayString;
34995 temp4 = true;
34996 int i, len=PySequence_Length(obj3);
34997 for (i=0; i<len; i++) {
34998 PyObject* item = PySequence_GetItem(obj3, i);
34999 wxString* s = wxString_in_helper(item);
35000 if (PyErr_Occurred()) SWIG_fail;
35001 arg4->Add(*s);
35002 delete s;
35003 Py_DECREF(item);
35004 }
35005 }
35006 {
35007 PyThreadState* __tstate = wxPyBeginAllowThreads();
35008 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
35009 wxPyEndAllowThreads(__tstate);
35010 if (PyErr_Occurred()) SWIG_fail;
35011 }
35012 {
35013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35014 }
35015 {
35016 if (temp4) delete arg4;
35017 }
35018 return resultobj;
35019 fail:
35020 {
35021 if (temp4) delete arg4;
35022 }
35023 return NULL;
35024 }
35025
35026
35027 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35028 PyObject *resultobj = 0;
35029 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35030 int arg2 ;
35031 int arg3 ;
35032 wxDragResult arg4 ;
35033 wxDragResult result;
35034 void *argp1 = 0 ;
35035 int res1 = 0 ;
35036 int val2 ;
35037 int ecode2 = 0 ;
35038 int val3 ;
35039 int ecode3 = 0 ;
35040 int val4 ;
35041 int ecode4 = 0 ;
35042 PyObject * obj0 = 0 ;
35043 PyObject * obj1 = 0 ;
35044 PyObject * obj2 = 0 ;
35045 PyObject * obj3 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35054 }
35055 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35056 ecode2 = SWIG_AsVal_int(obj1, &val2);
35057 if (!SWIG_IsOK(ecode2)) {
35058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
35059 }
35060 arg2 = static_cast< int >(val2);
35061 ecode3 = SWIG_AsVal_int(obj2, &val3);
35062 if (!SWIG_IsOK(ecode3)) {
35063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
35064 }
35065 arg3 = static_cast< int >(val3);
35066 ecode4 = SWIG_AsVal_int(obj3, &val4);
35067 if (!SWIG_IsOK(ecode4)) {
35068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
35069 }
35070 arg4 = static_cast< wxDragResult >(val4);
35071 {
35072 PyThreadState* __tstate = wxPyBeginAllowThreads();
35073 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
35074 wxPyEndAllowThreads(__tstate);
35075 if (PyErr_Occurred()) SWIG_fail;
35076 }
35077 resultobj = SWIG_From_int(static_cast< int >(result));
35078 return resultobj;
35079 fail:
35080 return NULL;
35081 }
35082
35083
35084 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35085 PyObject *resultobj = 0;
35086 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35087 int arg2 ;
35088 int arg3 ;
35089 wxDragResult arg4 ;
35090 wxDragResult result;
35091 void *argp1 = 0 ;
35092 int res1 = 0 ;
35093 int val2 ;
35094 int ecode2 = 0 ;
35095 int val3 ;
35096 int ecode3 = 0 ;
35097 int val4 ;
35098 int ecode4 = 0 ;
35099 PyObject * obj0 = 0 ;
35100 PyObject * obj1 = 0 ;
35101 PyObject * obj2 = 0 ;
35102 PyObject * obj3 = 0 ;
35103 char * kwnames[] = {
35104 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35105 };
35106
35107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35109 if (!SWIG_IsOK(res1)) {
35110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35111 }
35112 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35113 ecode2 = SWIG_AsVal_int(obj1, &val2);
35114 if (!SWIG_IsOK(ecode2)) {
35115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
35116 }
35117 arg2 = static_cast< int >(val2);
35118 ecode3 = SWIG_AsVal_int(obj2, &val3);
35119 if (!SWIG_IsOK(ecode3)) {
35120 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
35121 }
35122 arg3 = static_cast< int >(val3);
35123 ecode4 = SWIG_AsVal_int(obj3, &val4);
35124 if (!SWIG_IsOK(ecode4)) {
35125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
35126 }
35127 arg4 = static_cast< wxDragResult >(val4);
35128 {
35129 PyThreadState* __tstate = wxPyBeginAllowThreads();
35130 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
35131 wxPyEndAllowThreads(__tstate);
35132 if (PyErr_Occurred()) SWIG_fail;
35133 }
35134 resultobj = SWIG_From_int(static_cast< int >(result));
35135 return resultobj;
35136 fail:
35137 return NULL;
35138 }
35139
35140
35141 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35142 PyObject *resultobj = 0;
35143 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35144 void *argp1 = 0 ;
35145 int res1 = 0 ;
35146 PyObject *swig_obj[1] ;
35147
35148 if (!args) SWIG_fail;
35149 swig_obj[0] = args;
35150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35151 if (!SWIG_IsOK(res1)) {
35152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35153 }
35154 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35155 {
35156 PyThreadState* __tstate = wxPyBeginAllowThreads();
35157 (arg1)->OnLeave();
35158 wxPyEndAllowThreads(__tstate);
35159 if (PyErr_Occurred()) SWIG_fail;
35160 }
35161 resultobj = SWIG_Py_Void();
35162 return resultobj;
35163 fail:
35164 return NULL;
35165 }
35166
35167
35168 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35169 PyObject *resultobj = 0;
35170 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35171 int arg2 ;
35172 int arg3 ;
35173 bool result;
35174 void *argp1 = 0 ;
35175 int res1 = 0 ;
35176 int val2 ;
35177 int ecode2 = 0 ;
35178 int val3 ;
35179 int ecode3 = 0 ;
35180 PyObject * obj0 = 0 ;
35181 PyObject * obj1 = 0 ;
35182 PyObject * obj2 = 0 ;
35183 char * kwnames[] = {
35184 (char *) "self",(char *) "x",(char *) "y", NULL
35185 };
35186
35187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35189 if (!SWIG_IsOK(res1)) {
35190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35191 }
35192 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35193 ecode2 = SWIG_AsVal_int(obj1, &val2);
35194 if (!SWIG_IsOK(ecode2)) {
35195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
35196 }
35197 arg2 = static_cast< int >(val2);
35198 ecode3 = SWIG_AsVal_int(obj2, &val3);
35199 if (!SWIG_IsOK(ecode3)) {
35200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
35201 }
35202 arg3 = static_cast< int >(val3);
35203 {
35204 PyThreadState* __tstate = wxPyBeginAllowThreads();
35205 result = (bool)(arg1)->OnDrop(arg2,arg3);
35206 wxPyEndAllowThreads(__tstate);
35207 if (PyErr_Occurred()) SWIG_fail;
35208 }
35209 {
35210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35211 }
35212 return resultobj;
35213 fail:
35214 return NULL;
35215 }
35216
35217
35218 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35219 PyObject *resultobj = 0;
35220 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
35221 int arg2 ;
35222 int arg3 ;
35223 wxDragResult arg4 ;
35224 wxDragResult result;
35225 void *argp1 = 0 ;
35226 int res1 = 0 ;
35227 int val2 ;
35228 int ecode2 = 0 ;
35229 int val3 ;
35230 int ecode3 = 0 ;
35231 int val4 ;
35232 int ecode4 = 0 ;
35233 PyObject * obj0 = 0 ;
35234 PyObject * obj1 = 0 ;
35235 PyObject * obj2 = 0 ;
35236 PyObject * obj3 = 0 ;
35237 char * kwnames[] = {
35238 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
35239 };
35240
35241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
35243 if (!SWIG_IsOK(res1)) {
35244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
35245 }
35246 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
35247 ecode2 = SWIG_AsVal_int(obj1, &val2);
35248 if (!SWIG_IsOK(ecode2)) {
35249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
35250 }
35251 arg2 = static_cast< int >(val2);
35252 ecode3 = SWIG_AsVal_int(obj2, &val3);
35253 if (!SWIG_IsOK(ecode3)) {
35254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
35255 }
35256 arg3 = static_cast< int >(val3);
35257 ecode4 = SWIG_AsVal_int(obj3, &val4);
35258 if (!SWIG_IsOK(ecode4)) {
35259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
35260 }
35261 arg4 = static_cast< wxDragResult >(val4);
35262 {
35263 PyThreadState* __tstate = wxPyBeginAllowThreads();
35264 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
35265 wxPyEndAllowThreads(__tstate);
35266 if (PyErr_Occurred()) SWIG_fail;
35267 }
35268 resultobj = SWIG_From_int(static_cast< int >(result));
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35276 PyObject *obj;
35277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35278 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
35279 return SWIG_Py_Void();
35280 }
35281
35282 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35283 return SWIG_Python_InitShadowInstance(args);
35284 }
35285
35286 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35287 PyObject *resultobj = 0;
35288 wxClipboard *result = 0 ;
35289
35290 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
35291 {
35292 PyThreadState* __tstate = wxPyBeginAllowThreads();
35293 result = (wxClipboard *)new wxClipboard();
35294 wxPyEndAllowThreads(__tstate);
35295 if (PyErr_Occurred()) SWIG_fail;
35296 }
35297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
35298 return resultobj;
35299 fail:
35300 return NULL;
35301 }
35302
35303
35304 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35305 PyObject *resultobj = 0;
35306 wxClipboard *arg1 = (wxClipboard *) 0 ;
35307 void *argp1 = 0 ;
35308 int res1 = 0 ;
35309 PyObject *swig_obj[1] ;
35310
35311 if (!args) SWIG_fail;
35312 swig_obj[0] = args;
35313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
35314 if (!SWIG_IsOK(res1)) {
35315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
35316 }
35317 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35318 {
35319 PyThreadState* __tstate = wxPyBeginAllowThreads();
35320 delete arg1;
35321
35322 wxPyEndAllowThreads(__tstate);
35323 if (PyErr_Occurred()) SWIG_fail;
35324 }
35325 resultobj = SWIG_Py_Void();
35326 return resultobj;
35327 fail:
35328 return NULL;
35329 }
35330
35331
35332 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35333 PyObject *resultobj = 0;
35334 wxClipboard *arg1 = (wxClipboard *) 0 ;
35335 bool result;
35336 void *argp1 = 0 ;
35337 int res1 = 0 ;
35338 PyObject *swig_obj[1] ;
35339
35340 if (!args) SWIG_fail;
35341 swig_obj[0] = args;
35342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35343 if (!SWIG_IsOK(res1)) {
35344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
35345 }
35346 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35347 {
35348 PyThreadState* __tstate = wxPyBeginAllowThreads();
35349 result = (bool)(arg1)->Open();
35350 wxPyEndAllowThreads(__tstate);
35351 if (PyErr_Occurred()) SWIG_fail;
35352 }
35353 {
35354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35355 }
35356 return resultobj;
35357 fail:
35358 return NULL;
35359 }
35360
35361
35362 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35363 PyObject *resultobj = 0;
35364 wxClipboard *arg1 = (wxClipboard *) 0 ;
35365 void *argp1 = 0 ;
35366 int res1 = 0 ;
35367 PyObject *swig_obj[1] ;
35368
35369 if (!args) SWIG_fail;
35370 swig_obj[0] = args;
35371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35372 if (!SWIG_IsOK(res1)) {
35373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
35374 }
35375 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35376 {
35377 PyThreadState* __tstate = wxPyBeginAllowThreads();
35378 (arg1)->Close();
35379 wxPyEndAllowThreads(__tstate);
35380 if (PyErr_Occurred()) SWIG_fail;
35381 }
35382 resultobj = SWIG_Py_Void();
35383 return resultobj;
35384 fail:
35385 return NULL;
35386 }
35387
35388
35389 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35390 PyObject *resultobj = 0;
35391 wxClipboard *arg1 = (wxClipboard *) 0 ;
35392 bool result;
35393 void *argp1 = 0 ;
35394 int res1 = 0 ;
35395 PyObject *swig_obj[1] ;
35396
35397 if (!args) SWIG_fail;
35398 swig_obj[0] = args;
35399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35400 if (!SWIG_IsOK(res1)) {
35401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
35402 }
35403 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = (bool)((wxClipboard const *)arg1)->IsOpened();
35407 wxPyEndAllowThreads(__tstate);
35408 if (PyErr_Occurred()) SWIG_fail;
35409 }
35410 {
35411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35412 }
35413 return resultobj;
35414 fail:
35415 return NULL;
35416 }
35417
35418
35419 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35420 PyObject *resultobj = 0;
35421 wxClipboard *arg1 = (wxClipboard *) 0 ;
35422 wxDataObject *arg2 = (wxDataObject *) 0 ;
35423 bool result;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 int res2 = 0 ;
35427 PyObject * obj0 = 0 ;
35428 PyObject * obj1 = 0 ;
35429 char * kwnames[] = {
35430 (char *) "self",(char *) "data", NULL
35431 };
35432
35433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
35434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35435 if (!SWIG_IsOK(res1)) {
35436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35437 }
35438 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35439 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35440 if (!SWIG_IsOK(res2)) {
35441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35442 }
35443 {
35444 PyThreadState* __tstate = wxPyBeginAllowThreads();
35445 result = (bool)(arg1)->AddData(arg2);
35446 wxPyEndAllowThreads(__tstate);
35447 if (PyErr_Occurred()) SWIG_fail;
35448 }
35449 {
35450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35451 }
35452 return resultobj;
35453 fail:
35454 return NULL;
35455 }
35456
35457
35458 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35459 PyObject *resultobj = 0;
35460 wxClipboard *arg1 = (wxClipboard *) 0 ;
35461 wxDataObject *arg2 = (wxDataObject *) 0 ;
35462 bool result;
35463 void *argp1 = 0 ;
35464 int res1 = 0 ;
35465 int res2 = 0 ;
35466 PyObject * obj0 = 0 ;
35467 PyObject * obj1 = 0 ;
35468 char * kwnames[] = {
35469 (char *) "self",(char *) "data", NULL
35470 };
35471
35472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
35473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35474 if (!SWIG_IsOK(res1)) {
35475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35476 }
35477 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35478 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
35479 if (!SWIG_IsOK(res2)) {
35480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
35481 }
35482 {
35483 PyThreadState* __tstate = wxPyBeginAllowThreads();
35484 result = (bool)(arg1)->SetData(arg2);
35485 wxPyEndAllowThreads(__tstate);
35486 if (PyErr_Occurred()) SWIG_fail;
35487 }
35488 {
35489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35490 }
35491 return resultobj;
35492 fail:
35493 return NULL;
35494 }
35495
35496
35497 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35498 PyObject *resultobj = 0;
35499 wxClipboard *arg1 = (wxClipboard *) 0 ;
35500 wxDataFormat *arg2 = 0 ;
35501 bool result;
35502 void *argp1 = 0 ;
35503 int res1 = 0 ;
35504 void *argp2 = 0 ;
35505 int res2 = 0 ;
35506 PyObject * obj0 = 0 ;
35507 PyObject * obj1 = 0 ;
35508 char * kwnames[] = {
35509 (char *) "self",(char *) "format", NULL
35510 };
35511
35512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
35513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35514 if (!SWIG_IsOK(res1)) {
35515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
35516 }
35517 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35518 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
35519 if (!SWIG_IsOK(res2)) {
35520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35521 }
35522 if (!argp2) {
35523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
35524 }
35525 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
35526 {
35527 PyThreadState* __tstate = wxPyBeginAllowThreads();
35528 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
35529 wxPyEndAllowThreads(__tstate);
35530 if (PyErr_Occurred()) SWIG_fail;
35531 }
35532 {
35533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35534 }
35535 return resultobj;
35536 fail:
35537 return NULL;
35538 }
35539
35540
35541 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35542 PyObject *resultobj = 0;
35543 wxClipboard *arg1 = (wxClipboard *) 0 ;
35544 wxDataObject *arg2 = 0 ;
35545 bool result;
35546 void *argp1 = 0 ;
35547 int res1 = 0 ;
35548 void *argp2 = 0 ;
35549 int res2 = 0 ;
35550 PyObject * obj0 = 0 ;
35551 PyObject * obj1 = 0 ;
35552 char * kwnames[] = {
35553 (char *) "self",(char *) "data", NULL
35554 };
35555
35556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
35557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35558 if (!SWIG_IsOK(res1)) {
35559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
35560 }
35561 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35562 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
35563 if (!SWIG_IsOK(res2)) {
35564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35565 }
35566 if (!argp2) {
35567 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
35568 }
35569 arg2 = reinterpret_cast< wxDataObject * >(argp2);
35570 {
35571 PyThreadState* __tstate = wxPyBeginAllowThreads();
35572 result = (bool)(arg1)->GetData(*arg2);
35573 wxPyEndAllowThreads(__tstate);
35574 if (PyErr_Occurred()) SWIG_fail;
35575 }
35576 {
35577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35578 }
35579 return resultobj;
35580 fail:
35581 return NULL;
35582 }
35583
35584
35585 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35586 PyObject *resultobj = 0;
35587 wxClipboard *arg1 = (wxClipboard *) 0 ;
35588 void *argp1 = 0 ;
35589 int res1 = 0 ;
35590 PyObject *swig_obj[1] ;
35591
35592 if (!args) SWIG_fail;
35593 swig_obj[0] = args;
35594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35595 if (!SWIG_IsOK(res1)) {
35596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
35597 }
35598 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 (arg1)->Clear();
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 resultobj = SWIG_Py_Void();
35606 return resultobj;
35607 fail:
35608 return NULL;
35609 }
35610
35611
35612 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35613 PyObject *resultobj = 0;
35614 wxClipboard *arg1 = (wxClipboard *) 0 ;
35615 bool result;
35616 void *argp1 = 0 ;
35617 int res1 = 0 ;
35618 PyObject *swig_obj[1] ;
35619
35620 if (!args) SWIG_fail;
35621 swig_obj[0] = args;
35622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35623 if (!SWIG_IsOK(res1)) {
35624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
35625 }
35626 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35627 {
35628 PyThreadState* __tstate = wxPyBeginAllowThreads();
35629 result = (bool)(arg1)->Flush();
35630 wxPyEndAllowThreads(__tstate);
35631 if (PyErr_Occurred()) SWIG_fail;
35632 }
35633 {
35634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35635 }
35636 return resultobj;
35637 fail:
35638 return NULL;
35639 }
35640
35641
35642 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35643 PyObject *resultobj = 0;
35644 wxClipboard *arg1 = (wxClipboard *) 0 ;
35645 bool arg2 = (bool) true ;
35646 void *argp1 = 0 ;
35647 int res1 = 0 ;
35648 bool val2 ;
35649 int ecode2 = 0 ;
35650 PyObject * obj0 = 0 ;
35651 PyObject * obj1 = 0 ;
35652 char * kwnames[] = {
35653 (char *) "self",(char *) "primary", NULL
35654 };
35655
35656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
35657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35658 if (!SWIG_IsOK(res1)) {
35659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
35660 }
35661 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35662 if (obj1) {
35663 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35664 if (!SWIG_IsOK(ecode2)) {
35665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
35666 }
35667 arg2 = static_cast< bool >(val2);
35668 }
35669 {
35670 PyThreadState* __tstate = wxPyBeginAllowThreads();
35671 (arg1)->UsePrimarySelection(arg2);
35672 wxPyEndAllowThreads(__tstate);
35673 if (PyErr_Occurred()) SWIG_fail;
35674 }
35675 resultobj = SWIG_Py_Void();
35676 return resultobj;
35677 fail:
35678 return NULL;
35679 }
35680
35681
35682 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35683 PyObject *resultobj = 0;
35684 wxClipboard *result = 0 ;
35685
35686 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
35687 {
35688 PyThreadState* __tstate = wxPyBeginAllowThreads();
35689 result = (wxClipboard *)wxClipboard::Get();
35690 wxPyEndAllowThreads(__tstate);
35691 if (PyErr_Occurred()) SWIG_fail;
35692 }
35693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
35694 return resultobj;
35695 fail:
35696 return NULL;
35697 }
35698
35699
35700 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35701 PyObject *obj;
35702 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35703 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
35704 return SWIG_Py_Void();
35705 }
35706
35707 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35708 return SWIG_Python_InitShadowInstance(args);
35709 }
35710
35711 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35712 PyObject *resultobj = 0;
35713 wxClipboard *arg1 = (wxClipboard *) NULL ;
35714 wxClipboardLocker *result = 0 ;
35715 void *argp1 = 0 ;
35716 int res1 = 0 ;
35717 PyObject * obj0 = 0 ;
35718 char * kwnames[] = {
35719 (char *) "clipboard", NULL
35720 };
35721
35722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
35723 if (obj0) {
35724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
35725 if (!SWIG_IsOK(res1)) {
35726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
35727 }
35728 arg1 = reinterpret_cast< wxClipboard * >(argp1);
35729 }
35730 {
35731 PyThreadState* __tstate = wxPyBeginAllowThreads();
35732 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35744 PyObject *resultobj = 0;
35745 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35746 void *argp1 = 0 ;
35747 int res1 = 0 ;
35748 PyObject *swig_obj[1] ;
35749
35750 if (!args) SWIG_fail;
35751 swig_obj[0] = args;
35752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
35753 if (!SWIG_IsOK(res1)) {
35754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35755 }
35756 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 delete arg1;
35760
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 resultobj = SWIG_Py_Void();
35765 return resultobj;
35766 fail:
35767 return NULL;
35768 }
35769
35770
35771 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35772 PyObject *resultobj = 0;
35773 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
35774 bool result;
35775 void *argp1 = 0 ;
35776 int res1 = 0 ;
35777 PyObject *swig_obj[1] ;
35778
35779 if (!args) SWIG_fail;
35780 swig_obj[0] = args;
35781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
35782 if (!SWIG_IsOK(res1)) {
35783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
35784 }
35785 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
35786 {
35787 PyThreadState* __tstate = wxPyBeginAllowThreads();
35788 result = (bool)wxClipboardLocker___nonzero__(arg1);
35789 wxPyEndAllowThreads(__tstate);
35790 if (PyErr_Occurred()) SWIG_fail;
35791 }
35792 {
35793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35794 }
35795 return resultobj;
35796 fail:
35797 return NULL;
35798 }
35799
35800
35801 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35802 PyObject *obj;
35803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35804 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
35805 return SWIG_Py_Void();
35806 }
35807
35808 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35809 return SWIG_Python_InitShadowInstance(args);
35810 }
35811
35812 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35813 PyObject *resultobj = 0;
35814 int arg1 = (int) 0 ;
35815 int arg2 = (int) 0 ;
35816 int arg3 = (int) 0 ;
35817 int arg4 = (int) 0 ;
35818 wxVideoMode *result = 0 ;
35819 int val1 ;
35820 int ecode1 = 0 ;
35821 int val2 ;
35822 int ecode2 = 0 ;
35823 int val3 ;
35824 int ecode3 = 0 ;
35825 int val4 ;
35826 int ecode4 = 0 ;
35827 PyObject * obj0 = 0 ;
35828 PyObject * obj1 = 0 ;
35829 PyObject * obj2 = 0 ;
35830 PyObject * obj3 = 0 ;
35831 char * kwnames[] = {
35832 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
35833 };
35834
35835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35836 if (obj0) {
35837 ecode1 = SWIG_AsVal_int(obj0, &val1);
35838 if (!SWIG_IsOK(ecode1)) {
35839 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
35840 }
35841 arg1 = static_cast< int >(val1);
35842 }
35843 if (obj1) {
35844 ecode2 = SWIG_AsVal_int(obj1, &val2);
35845 if (!SWIG_IsOK(ecode2)) {
35846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
35847 }
35848 arg2 = static_cast< int >(val2);
35849 }
35850 if (obj2) {
35851 ecode3 = SWIG_AsVal_int(obj2, &val3);
35852 if (!SWIG_IsOK(ecode3)) {
35853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
35854 }
35855 arg3 = static_cast< int >(val3);
35856 }
35857 if (obj3) {
35858 ecode4 = SWIG_AsVal_int(obj3, &val4);
35859 if (!SWIG_IsOK(ecode4)) {
35860 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
35861 }
35862 arg4 = static_cast< int >(val4);
35863 }
35864 {
35865 PyThreadState* __tstate = wxPyBeginAllowThreads();
35866 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
35867 wxPyEndAllowThreads(__tstate);
35868 if (PyErr_Occurred()) SWIG_fail;
35869 }
35870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
35871 return resultobj;
35872 fail:
35873 return NULL;
35874 }
35875
35876
35877 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35878 PyObject *resultobj = 0;
35879 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35880 void *argp1 = 0 ;
35881 int res1 = 0 ;
35882 PyObject *swig_obj[1] ;
35883
35884 if (!args) SWIG_fail;
35885 swig_obj[0] = args;
35886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
35887 if (!SWIG_IsOK(res1)) {
35888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35889 }
35890 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 delete arg1;
35894
35895 wxPyEndAllowThreads(__tstate);
35896 if (PyErr_Occurred()) SWIG_fail;
35897 }
35898 resultobj = SWIG_Py_Void();
35899 return resultobj;
35900 fail:
35901 return NULL;
35902 }
35903
35904
35905 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35906 PyObject *resultobj = 0;
35907 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35908 wxVideoMode *arg2 = 0 ;
35909 bool result;
35910 void *argp1 = 0 ;
35911 int res1 = 0 ;
35912 void *argp2 = 0 ;
35913 int res2 = 0 ;
35914 PyObject * obj0 = 0 ;
35915 PyObject * obj1 = 0 ;
35916 char * kwnames[] = {
35917 (char *) "self",(char *) "other", NULL
35918 };
35919
35920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
35921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35922 if (!SWIG_IsOK(res1)) {
35923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35924 }
35925 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35927 if (!SWIG_IsOK(res2)) {
35928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35929 }
35930 if (!argp2) {
35931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35932 }
35933 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35934 {
35935 PyThreadState* __tstate = wxPyBeginAllowThreads();
35936 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
35937 wxPyEndAllowThreads(__tstate);
35938 if (PyErr_Occurred()) SWIG_fail;
35939 }
35940 {
35941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35942 }
35943 return resultobj;
35944 fail:
35945 return NULL;
35946 }
35947
35948
35949 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35950 PyObject *resultobj = 0;
35951 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35952 int result;
35953 void *argp1 = 0 ;
35954 int res1 = 0 ;
35955 PyObject *swig_obj[1] ;
35956
35957 if (!args) SWIG_fail;
35958 swig_obj[0] = args;
35959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35960 if (!SWIG_IsOK(res1)) {
35961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35962 }
35963 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35964 {
35965 PyThreadState* __tstate = wxPyBeginAllowThreads();
35966 result = (int)((wxVideoMode const *)arg1)->GetWidth();
35967 wxPyEndAllowThreads(__tstate);
35968 if (PyErr_Occurred()) SWIG_fail;
35969 }
35970 resultobj = SWIG_From_int(static_cast< int >(result));
35971 return resultobj;
35972 fail:
35973 return NULL;
35974 }
35975
35976
35977 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35978 PyObject *resultobj = 0;
35979 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35980 int result;
35981 void *argp1 = 0 ;
35982 int res1 = 0 ;
35983 PyObject *swig_obj[1] ;
35984
35985 if (!args) SWIG_fail;
35986 swig_obj[0] = args;
35987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35988 if (!SWIG_IsOK(res1)) {
35989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
35990 }
35991 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35992 {
35993 PyThreadState* __tstate = wxPyBeginAllowThreads();
35994 result = (int)((wxVideoMode const *)arg1)->GetHeight();
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 resultobj = SWIG_From_int(static_cast< int >(result));
35999 return resultobj;
36000 fail:
36001 return NULL;
36002 }
36003
36004
36005 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36006 PyObject *resultobj = 0;
36007 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36008 int result;
36009 void *argp1 = 0 ;
36010 int res1 = 0 ;
36011 PyObject *swig_obj[1] ;
36012
36013 if (!args) SWIG_fail;
36014 swig_obj[0] = args;
36015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36016 if (!SWIG_IsOK(res1)) {
36017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36018 }
36019 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 result = (int)((wxVideoMode const *)arg1)->GetDepth();
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 resultobj = SWIG_From_int(static_cast< int >(result));
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36034 PyObject *resultobj = 0;
36035 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36036 bool result;
36037 void *argp1 = 0 ;
36038 int res1 = 0 ;
36039 PyObject *swig_obj[1] ;
36040
36041 if (!args) SWIG_fail;
36042 swig_obj[0] = args;
36043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36044 if (!SWIG_IsOK(res1)) {
36045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
36046 }
36047 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36048 {
36049 PyThreadState* __tstate = wxPyBeginAllowThreads();
36050 result = (bool)((wxVideoMode const *)arg1)->IsOk();
36051 wxPyEndAllowThreads(__tstate);
36052 if (PyErr_Occurred()) SWIG_fail;
36053 }
36054 {
36055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36056 }
36057 return resultobj;
36058 fail:
36059 return NULL;
36060 }
36061
36062
36063 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36064 PyObject *resultobj = 0;
36065 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36066 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36067 bool result;
36068 void *argp1 = 0 ;
36069 int res1 = 0 ;
36070 void *argp2 = 0 ;
36071 int res2 = 0 ;
36072 PyObject * obj0 = 0 ;
36073 PyObject * obj1 = 0 ;
36074 char * kwnames[] = {
36075 (char *) "self",(char *) "other", NULL
36076 };
36077
36078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
36079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36080 if (!SWIG_IsOK(res1)) {
36081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36082 }
36083 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36085 if (!SWIG_IsOK(res2)) {
36086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36087 }
36088 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
36092 wxPyEndAllowThreads(__tstate);
36093 if (PyErr_Occurred()) SWIG_fail;
36094 }
36095 {
36096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36097 }
36098 return resultobj;
36099 fail:
36100 return NULL;
36101 }
36102
36103
36104 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36105 PyObject *resultobj = 0;
36106 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36107 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
36108 bool result;
36109 void *argp1 = 0 ;
36110 int res1 = 0 ;
36111 void *argp2 = 0 ;
36112 int res2 = 0 ;
36113 PyObject * obj0 = 0 ;
36114 PyObject * obj1 = 0 ;
36115 char * kwnames[] = {
36116 (char *) "self",(char *) "other", NULL
36117 };
36118
36119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
36120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36121 if (!SWIG_IsOK(res1)) {
36122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36123 }
36124 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36126 if (!SWIG_IsOK(res2)) {
36127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
36128 }
36129 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36130 {
36131 PyThreadState* __tstate = wxPyBeginAllowThreads();
36132 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
36133 wxPyEndAllowThreads(__tstate);
36134 if (PyErr_Occurred()) SWIG_fail;
36135 }
36136 {
36137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36138 }
36139 return resultobj;
36140 fail:
36141 return NULL;
36142 }
36143
36144
36145 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36146 PyObject *resultobj = 0;
36147 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36148 int arg2 ;
36149 void *argp1 = 0 ;
36150 int res1 = 0 ;
36151 int val2 ;
36152 int ecode2 = 0 ;
36153 PyObject *swig_obj[2] ;
36154
36155 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
36156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36157 if (!SWIG_IsOK(res1)) {
36158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36159 }
36160 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36161 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36162 if (!SWIG_IsOK(ecode2)) {
36163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
36164 }
36165 arg2 = static_cast< int >(val2);
36166 if (arg1) (arg1)->w = arg2;
36167
36168 resultobj = SWIG_Py_Void();
36169 return resultobj;
36170 fail:
36171 return NULL;
36172 }
36173
36174
36175 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36176 PyObject *resultobj = 0;
36177 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36178 int result;
36179 void *argp1 = 0 ;
36180 int res1 = 0 ;
36181 PyObject *swig_obj[1] ;
36182
36183 if (!args) SWIG_fail;
36184 swig_obj[0] = args;
36185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36186 if (!SWIG_IsOK(res1)) {
36187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36188 }
36189 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36190 result = (int) ((arg1)->w);
36191 resultobj = SWIG_From_int(static_cast< int >(result));
36192 return resultobj;
36193 fail:
36194 return NULL;
36195 }
36196
36197
36198 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36199 PyObject *resultobj = 0;
36200 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36201 int arg2 ;
36202 void *argp1 = 0 ;
36203 int res1 = 0 ;
36204 int val2 ;
36205 int ecode2 = 0 ;
36206 PyObject *swig_obj[2] ;
36207
36208 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
36209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36210 if (!SWIG_IsOK(res1)) {
36211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36212 }
36213 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36214 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36215 if (!SWIG_IsOK(ecode2)) {
36216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
36217 }
36218 arg2 = static_cast< int >(val2);
36219 if (arg1) (arg1)->h = arg2;
36220
36221 resultobj = SWIG_Py_Void();
36222 return resultobj;
36223 fail:
36224 return NULL;
36225 }
36226
36227
36228 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36229 PyObject *resultobj = 0;
36230 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36231 int result;
36232 void *argp1 = 0 ;
36233 int res1 = 0 ;
36234 PyObject *swig_obj[1] ;
36235
36236 if (!args) SWIG_fail;
36237 swig_obj[0] = args;
36238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36239 if (!SWIG_IsOK(res1)) {
36240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36241 }
36242 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36243 result = (int) ((arg1)->h);
36244 resultobj = SWIG_From_int(static_cast< int >(result));
36245 return resultobj;
36246 fail:
36247 return NULL;
36248 }
36249
36250
36251 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36252 PyObject *resultobj = 0;
36253 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36254 int arg2 ;
36255 void *argp1 = 0 ;
36256 int res1 = 0 ;
36257 int val2 ;
36258 int ecode2 = 0 ;
36259 PyObject *swig_obj[2] ;
36260
36261 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
36262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36263 if (!SWIG_IsOK(res1)) {
36264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36265 }
36266 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36267 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36268 if (!SWIG_IsOK(ecode2)) {
36269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
36270 }
36271 arg2 = static_cast< int >(val2);
36272 if (arg1) (arg1)->bpp = arg2;
36273
36274 resultobj = SWIG_Py_Void();
36275 return resultobj;
36276 fail:
36277 return NULL;
36278 }
36279
36280
36281 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36282 PyObject *resultobj = 0;
36283 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36284 int result;
36285 void *argp1 = 0 ;
36286 int res1 = 0 ;
36287 PyObject *swig_obj[1] ;
36288
36289 if (!args) SWIG_fail;
36290 swig_obj[0] = args;
36291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36292 if (!SWIG_IsOK(res1)) {
36293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36294 }
36295 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36296 result = (int) ((arg1)->bpp);
36297 resultobj = SWIG_From_int(static_cast< int >(result));
36298 return resultobj;
36299 fail:
36300 return NULL;
36301 }
36302
36303
36304 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36305 PyObject *resultobj = 0;
36306 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36307 int arg2 ;
36308 void *argp1 = 0 ;
36309 int res1 = 0 ;
36310 int val2 ;
36311 int ecode2 = 0 ;
36312 PyObject *swig_obj[2] ;
36313
36314 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
36315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36318 }
36319 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36320 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
36321 if (!SWIG_IsOK(ecode2)) {
36322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
36323 }
36324 arg2 = static_cast< int >(val2);
36325 if (arg1) (arg1)->refresh = arg2;
36326
36327 resultobj = SWIG_Py_Void();
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36335 PyObject *resultobj = 0;
36336 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
36337 int result;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 PyObject *swig_obj[1] ;
36341
36342 if (!args) SWIG_fail;
36343 swig_obj[0] = args;
36344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
36345 if (!SWIG_IsOK(res1)) {
36346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
36347 }
36348 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
36349 result = (int) ((arg1)->refresh);
36350 resultobj = SWIG_From_int(static_cast< int >(result));
36351 return resultobj;
36352 fail:
36353 return NULL;
36354 }
36355
36356
36357 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36358 PyObject *obj;
36359 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36360 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
36361 return SWIG_Py_Void();
36362 }
36363
36364 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36365 return SWIG_Python_InitShadowInstance(args);
36366 }
36367
36368 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
36369 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
36370 return 1;
36371 }
36372
36373
36374 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
36375 PyObject *pyobj = 0;
36376
36377 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
36378 return pyobj;
36379 }
36380
36381
36382 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36383 PyObject *resultobj = 0;
36384 unsigned int arg1 = (unsigned int) 0 ;
36385 wxDisplay *result = 0 ;
36386 unsigned int val1 ;
36387 int ecode1 = 0 ;
36388 PyObject * obj0 = 0 ;
36389 char * kwnames[] = {
36390 (char *) "index", NULL
36391 };
36392
36393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
36394 if (obj0) {
36395 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
36396 if (!SWIG_IsOK(ecode1)) {
36397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "unsigned int""'");
36398 }
36399 arg1 = static_cast< unsigned int >(val1);
36400 }
36401 {
36402 PyThreadState* __tstate = wxPyBeginAllowThreads();
36403 result = (wxDisplay *)new wxDisplay(arg1);
36404 wxPyEndAllowThreads(__tstate);
36405 if (PyErr_Occurred()) SWIG_fail;
36406 }
36407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
36408 return resultobj;
36409 fail:
36410 return NULL;
36411 }
36412
36413
36414 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36415 PyObject *resultobj = 0;
36416 wxDisplay *arg1 = (wxDisplay *) 0 ;
36417 void *argp1 = 0 ;
36418 int res1 = 0 ;
36419 PyObject *swig_obj[1] ;
36420
36421 if (!args) SWIG_fail;
36422 swig_obj[0] = args;
36423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
36424 if (!SWIG_IsOK(res1)) {
36425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
36426 }
36427 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36428 {
36429 PyThreadState* __tstate = wxPyBeginAllowThreads();
36430 delete arg1;
36431
36432 wxPyEndAllowThreads(__tstate);
36433 if (PyErr_Occurred()) SWIG_fail;
36434 }
36435 resultobj = SWIG_Py_Void();
36436 return resultobj;
36437 fail:
36438 return NULL;
36439 }
36440
36441
36442 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36443 PyObject *resultobj = 0;
36444 unsigned int result;
36445
36446 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 result = (unsigned int)wxDisplay::GetCount();
36450 wxPyEndAllowThreads(__tstate);
36451 if (PyErr_Occurred()) SWIG_fail;
36452 }
36453 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
36454 return resultobj;
36455 fail:
36456 return NULL;
36457 }
36458
36459
36460 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36461 PyObject *resultobj = 0;
36462 wxPoint *arg1 = 0 ;
36463 int result;
36464 wxPoint temp1 ;
36465 PyObject * obj0 = 0 ;
36466 char * kwnames[] = {
36467 (char *) "pt", NULL
36468 };
36469
36470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
36471 {
36472 arg1 = &temp1;
36473 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
36474 }
36475 {
36476 PyThreadState* __tstate = wxPyBeginAllowThreads();
36477 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
36478 wxPyEndAllowThreads(__tstate);
36479 if (PyErr_Occurred()) SWIG_fail;
36480 }
36481 resultobj = SWIG_From_int(static_cast< int >(result));
36482 return resultobj;
36483 fail:
36484 return NULL;
36485 }
36486
36487
36488 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36489 PyObject *resultobj = 0;
36490 wxWindow *arg1 = (wxWindow *) 0 ;
36491 int result;
36492 void *argp1 = 0 ;
36493 int res1 = 0 ;
36494 PyObject * obj0 = 0 ;
36495 char * kwnames[] = {
36496 (char *) "window", NULL
36497 };
36498
36499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
36500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36501 if (!SWIG_IsOK(res1)) {
36502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36503 }
36504 arg1 = reinterpret_cast< wxWindow * >(argp1);
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 result = (int)wxDisplay::GetFromWindow(arg1);
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 resultobj = SWIG_From_int(static_cast< int >(result));
36512 return resultobj;
36513 fail:
36514 return NULL;
36515 }
36516
36517
36518 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36519 PyObject *resultobj = 0;
36520 wxDisplay *arg1 = (wxDisplay *) 0 ;
36521 bool result;
36522 void *argp1 = 0 ;
36523 int res1 = 0 ;
36524 PyObject *swig_obj[1] ;
36525
36526 if (!args) SWIG_fail;
36527 swig_obj[0] = args;
36528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36529 if (!SWIG_IsOK(res1)) {
36530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36531 }
36532 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36533 {
36534 PyThreadState* __tstate = wxPyBeginAllowThreads();
36535 result = (bool)((wxDisplay const *)arg1)->IsOk();
36536 wxPyEndAllowThreads(__tstate);
36537 if (PyErr_Occurred()) SWIG_fail;
36538 }
36539 {
36540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36541 }
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36549 PyObject *resultobj = 0;
36550 wxDisplay *arg1 = (wxDisplay *) 0 ;
36551 wxRect result;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 PyObject *swig_obj[1] ;
36555
36556 if (!args) SWIG_fail;
36557 swig_obj[0] = args;
36558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36561 }
36562 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36563 {
36564 PyThreadState* __tstate = wxPyBeginAllowThreads();
36565 result = ((wxDisplay const *)arg1)->GetGeometry();
36566 wxPyEndAllowThreads(__tstate);
36567 if (PyErr_Occurred()) SWIG_fail;
36568 }
36569 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36570 return resultobj;
36571 fail:
36572 return NULL;
36573 }
36574
36575
36576 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36577 PyObject *resultobj = 0;
36578 wxDisplay *arg1 = (wxDisplay *) 0 ;
36579 wxRect result;
36580 void *argp1 = 0 ;
36581 int res1 = 0 ;
36582 PyObject *swig_obj[1] ;
36583
36584 if (!args) SWIG_fail;
36585 swig_obj[0] = args;
36586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36587 if (!SWIG_IsOK(res1)) {
36588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36589 }
36590 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36591 {
36592 PyThreadState* __tstate = wxPyBeginAllowThreads();
36593 result = ((wxDisplay const *)arg1)->GetClientArea();
36594 wxPyEndAllowThreads(__tstate);
36595 if (PyErr_Occurred()) SWIG_fail;
36596 }
36597 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
36598 return resultobj;
36599 fail:
36600 return NULL;
36601 }
36602
36603
36604 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36605 PyObject *resultobj = 0;
36606 wxDisplay *arg1 = (wxDisplay *) 0 ;
36607 wxString result;
36608 void *argp1 = 0 ;
36609 int res1 = 0 ;
36610 PyObject *swig_obj[1] ;
36611
36612 if (!args) SWIG_fail;
36613 swig_obj[0] = args;
36614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36615 if (!SWIG_IsOK(res1)) {
36616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36617 }
36618 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36619 {
36620 PyThreadState* __tstate = wxPyBeginAllowThreads();
36621 result = ((wxDisplay const *)arg1)->GetName();
36622 wxPyEndAllowThreads(__tstate);
36623 if (PyErr_Occurred()) SWIG_fail;
36624 }
36625 {
36626 #if wxUSE_UNICODE
36627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36628 #else
36629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36630 #endif
36631 }
36632 return resultobj;
36633 fail:
36634 return NULL;
36635 }
36636
36637
36638 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36639 PyObject *resultobj = 0;
36640 wxDisplay *arg1 = (wxDisplay *) 0 ;
36641 bool result;
36642 void *argp1 = 0 ;
36643 int res1 = 0 ;
36644 PyObject *swig_obj[1] ;
36645
36646 if (!args) SWIG_fail;
36647 swig_obj[0] = args;
36648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36649 if (!SWIG_IsOK(res1)) {
36650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36651 }
36652 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 {
36660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36661 }
36662 return resultobj;
36663 fail:
36664 return NULL;
36665 }
36666
36667
36668 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36669 PyObject *resultobj = 0;
36670 wxDisplay *arg1 = (wxDisplay *) 0 ;
36671 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36672 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36673 PyObject *result = 0 ;
36674 void *argp1 = 0 ;
36675 int res1 = 0 ;
36676 void *argp2 = 0 ;
36677 int res2 = 0 ;
36678 PyObject * obj0 = 0 ;
36679 PyObject * obj1 = 0 ;
36680 char * kwnames[] = {
36681 (char *) "self",(char *) "mode", NULL
36682 };
36683
36684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
36685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36686 if (!SWIG_IsOK(res1)) {
36687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
36688 }
36689 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36690 if (obj1) {
36691 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36692 if (!SWIG_IsOK(res2)) {
36693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36694 }
36695 if (!argp2) {
36696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36697 }
36698 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36699 }
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 resultobj = result;
36707 return resultobj;
36708 fail:
36709 return NULL;
36710 }
36711
36712
36713 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36714 PyObject *resultobj = 0;
36715 wxDisplay *arg1 = (wxDisplay *) 0 ;
36716 wxVideoMode result;
36717 void *argp1 = 0 ;
36718 int res1 = 0 ;
36719 PyObject *swig_obj[1] ;
36720
36721 if (!args) SWIG_fail;
36722 swig_obj[0] = args;
36723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36724 if (!SWIG_IsOK(res1)) {
36725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
36726 }
36727 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36728 {
36729 PyThreadState* __tstate = wxPyBeginAllowThreads();
36730 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
36731 wxPyEndAllowThreads(__tstate);
36732 if (PyErr_Occurred()) SWIG_fail;
36733 }
36734 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
36735 return resultobj;
36736 fail:
36737 return NULL;
36738 }
36739
36740
36741 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36742 PyObject *resultobj = 0;
36743 wxDisplay *arg1 = (wxDisplay *) 0 ;
36744 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
36745 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
36746 bool result;
36747 void *argp1 = 0 ;
36748 int res1 = 0 ;
36749 void *argp2 = 0 ;
36750 int res2 = 0 ;
36751 PyObject * obj0 = 0 ;
36752 PyObject * obj1 = 0 ;
36753 char * kwnames[] = {
36754 (char *) "self",(char *) "mode", NULL
36755 };
36756
36757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
36758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36759 if (!SWIG_IsOK(res1)) {
36760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36761 }
36762 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36763 if (obj1) {
36764 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
36765 if (!SWIG_IsOK(res2)) {
36766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36767 }
36768 if (!argp2) {
36769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
36770 }
36771 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
36772 }
36773 {
36774 PyThreadState* __tstate = wxPyBeginAllowThreads();
36775 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 {
36780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36781 }
36782 return resultobj;
36783 fail:
36784 return NULL;
36785 }
36786
36787
36788 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36789 PyObject *resultobj = 0;
36790 wxDisplay *arg1 = (wxDisplay *) 0 ;
36791 void *argp1 = 0 ;
36792 int res1 = 0 ;
36793 PyObject *swig_obj[1] ;
36794
36795 if (!args) SWIG_fail;
36796 swig_obj[0] = args;
36797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
36798 if (!SWIG_IsOK(res1)) {
36799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
36800 }
36801 arg1 = reinterpret_cast< wxDisplay * >(argp1);
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 wxDisplay_ResetMode(arg1);
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 resultobj = SWIG_Py_Void();
36809 return resultobj;
36810 fail:
36811 return NULL;
36812 }
36813
36814
36815 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36816 PyObject *obj;
36817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36818 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
36819 return SWIG_Py_Void();
36820 }
36821
36822 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36823 return SWIG_Python_InitShadowInstance(args);
36824 }
36825
36826 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36827 PyObject *resultobj = 0;
36828 wxStandardPaths *result = 0 ;
36829
36830 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
36831 {
36832 PyThreadState* __tstate = wxPyBeginAllowThreads();
36833 result = (wxStandardPaths *)wxStandardPaths_Get();
36834 wxPyEndAllowThreads(__tstate);
36835 if (PyErr_Occurred()) SWIG_fail;
36836 }
36837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36838 return resultobj;
36839 fail:
36840 return NULL;
36841 }
36842
36843
36844 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36845 PyObject *resultobj = 0;
36846 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36847 wxString result;
36848 void *argp1 = 0 ;
36849 int res1 = 0 ;
36850 PyObject *swig_obj[1] ;
36851
36852 if (!args) SWIG_fail;
36853 swig_obj[0] = args;
36854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36855 if (!SWIG_IsOK(res1)) {
36856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36857 }
36858 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36859 {
36860 PyThreadState* __tstate = wxPyBeginAllowThreads();
36861 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
36862 wxPyEndAllowThreads(__tstate);
36863 if (PyErr_Occurred()) SWIG_fail;
36864 }
36865 {
36866 #if wxUSE_UNICODE
36867 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36868 #else
36869 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36870 #endif
36871 }
36872 return resultobj;
36873 fail:
36874 return NULL;
36875 }
36876
36877
36878 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36879 PyObject *resultobj = 0;
36880 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36881 wxString result;
36882 void *argp1 = 0 ;
36883 int res1 = 0 ;
36884 PyObject *swig_obj[1] ;
36885
36886 if (!args) SWIG_fail;
36887 swig_obj[0] = args;
36888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36889 if (!SWIG_IsOK(res1)) {
36890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36891 }
36892 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36893 {
36894 PyThreadState* __tstate = wxPyBeginAllowThreads();
36895 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
36896 wxPyEndAllowThreads(__tstate);
36897 if (PyErr_Occurred()) SWIG_fail;
36898 }
36899 {
36900 #if wxUSE_UNICODE
36901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36902 #else
36903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36904 #endif
36905 }
36906 return resultobj;
36907 fail:
36908 return NULL;
36909 }
36910
36911
36912 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36913 PyObject *resultobj = 0;
36914 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36915 wxString result;
36916 void *argp1 = 0 ;
36917 int res1 = 0 ;
36918 PyObject *swig_obj[1] ;
36919
36920 if (!args) SWIG_fail;
36921 swig_obj[0] = args;
36922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36923 if (!SWIG_IsOK(res1)) {
36924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36925 }
36926 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36927 {
36928 PyThreadState* __tstate = wxPyBeginAllowThreads();
36929 result = ((wxStandardPaths const *)arg1)->GetDataDir();
36930 wxPyEndAllowThreads(__tstate);
36931 if (PyErr_Occurred()) SWIG_fail;
36932 }
36933 {
36934 #if wxUSE_UNICODE
36935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36936 #else
36937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36938 #endif
36939 }
36940 return resultobj;
36941 fail:
36942 return NULL;
36943 }
36944
36945
36946 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36947 PyObject *resultobj = 0;
36948 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36949 wxString result;
36950 void *argp1 = 0 ;
36951 int res1 = 0 ;
36952 PyObject *swig_obj[1] ;
36953
36954 if (!args) SWIG_fail;
36955 swig_obj[0] = args;
36956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36957 if (!SWIG_IsOK(res1)) {
36958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36959 }
36960 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 {
36968 #if wxUSE_UNICODE
36969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36970 #else
36971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36972 #endif
36973 }
36974 return resultobj;
36975 fail:
36976 return NULL;
36977 }
36978
36979
36980 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36981 PyObject *resultobj = 0;
36982 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36983 wxString result;
36984 void *argp1 = 0 ;
36985 int res1 = 0 ;
36986 PyObject *swig_obj[1] ;
36987
36988 if (!args) SWIG_fail;
36989 swig_obj[0] = args;
36990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36991 if (!SWIG_IsOK(res1)) {
36992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36993 }
36994 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36995 {
36996 PyThreadState* __tstate = wxPyBeginAllowThreads();
36997 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
36998 wxPyEndAllowThreads(__tstate);
36999 if (PyErr_Occurred()) SWIG_fail;
37000 }
37001 {
37002 #if wxUSE_UNICODE
37003 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37004 #else
37005 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37006 #endif
37007 }
37008 return resultobj;
37009 fail:
37010 return NULL;
37011 }
37012
37013
37014 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37015 PyObject *resultobj = 0;
37016 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37017 wxString result;
37018 void *argp1 = 0 ;
37019 int res1 = 0 ;
37020 PyObject *swig_obj[1] ;
37021
37022 if (!args) SWIG_fail;
37023 swig_obj[0] = args;
37024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37025 if (!SWIG_IsOK(res1)) {
37026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37027 }
37028 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37029 {
37030 PyThreadState* __tstate = wxPyBeginAllowThreads();
37031 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
37032 wxPyEndAllowThreads(__tstate);
37033 if (PyErr_Occurred()) SWIG_fail;
37034 }
37035 {
37036 #if wxUSE_UNICODE
37037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37038 #else
37039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37040 #endif
37041 }
37042 return resultobj;
37043 fail:
37044 return NULL;
37045 }
37046
37047
37048 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37049 PyObject *resultobj = 0;
37050 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37051 wxString result;
37052 void *argp1 = 0 ;
37053 int res1 = 0 ;
37054 PyObject *swig_obj[1] ;
37055
37056 if (!args) SWIG_fail;
37057 swig_obj[0] = args;
37058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37059 if (!SWIG_IsOK(res1)) {
37060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37061 }
37062 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37063 {
37064 PyThreadState* __tstate = wxPyBeginAllowThreads();
37065 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
37066 wxPyEndAllowThreads(__tstate);
37067 if (PyErr_Occurred()) SWIG_fail;
37068 }
37069 {
37070 #if wxUSE_UNICODE
37071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37072 #else
37073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37074 #endif
37075 }
37076 return resultobj;
37077 fail:
37078 return NULL;
37079 }
37080
37081
37082 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37083 PyObject *resultobj = 0;
37084 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37085 wxString result;
37086 void *argp1 = 0 ;
37087 int res1 = 0 ;
37088 PyObject *swig_obj[1] ;
37089
37090 if (!args) SWIG_fail;
37091 swig_obj[0] = args;
37092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37093 if (!SWIG_IsOK(res1)) {
37094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37095 }
37096 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37097 {
37098 PyThreadState* __tstate = wxPyBeginAllowThreads();
37099 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
37100 wxPyEndAllowThreads(__tstate);
37101 if (PyErr_Occurred()) SWIG_fail;
37102 }
37103 {
37104 #if wxUSE_UNICODE
37105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37106 #else
37107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37108 #endif
37109 }
37110 return resultobj;
37111 fail:
37112 return NULL;
37113 }
37114
37115
37116 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37117 PyObject *resultobj = 0;
37118 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37119 wxString *arg2 = 0 ;
37120 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
37121 wxString result;
37122 void *argp1 = 0 ;
37123 int res1 = 0 ;
37124 bool temp2 = false ;
37125 int val3 ;
37126 int ecode3 = 0 ;
37127 PyObject * obj0 = 0 ;
37128 PyObject * obj1 = 0 ;
37129 PyObject * obj2 = 0 ;
37130 char * kwnames[] = {
37131 (char *) "self",(char *) "lang",(char *) "category", NULL
37132 };
37133
37134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37136 if (!SWIG_IsOK(res1)) {
37137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37138 }
37139 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37140 {
37141 arg2 = wxString_in_helper(obj1);
37142 if (arg2 == NULL) SWIG_fail;
37143 temp2 = true;
37144 }
37145 if (obj2) {
37146 ecode3 = SWIG_AsVal_int(obj2, &val3);
37147 if (!SWIG_IsOK(ecode3)) {
37148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
37149 }
37150 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
37151 }
37152 {
37153 PyThreadState* __tstate = wxPyBeginAllowThreads();
37154 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
37155 wxPyEndAllowThreads(__tstate);
37156 if (PyErr_Occurred()) SWIG_fail;
37157 }
37158 {
37159 #if wxUSE_UNICODE
37160 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37161 #else
37162 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37163 #endif
37164 }
37165 {
37166 if (temp2)
37167 delete arg2;
37168 }
37169 return resultobj;
37170 fail:
37171 {
37172 if (temp2)
37173 delete arg2;
37174 }
37175 return NULL;
37176 }
37177
37178
37179 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37180 PyObject *resultobj = 0;
37181 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37182 wxString result;
37183 void *argp1 = 0 ;
37184 int res1 = 0 ;
37185 PyObject *swig_obj[1] ;
37186
37187 if (!args) SWIG_fail;
37188 swig_obj[0] = args;
37189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37190 if (!SWIG_IsOK(res1)) {
37191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37192 }
37193 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37194 {
37195 PyThreadState* __tstate = wxPyBeginAllowThreads();
37196 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 {
37201 #if wxUSE_UNICODE
37202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37203 #else
37204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37205 #endif
37206 }
37207 return resultobj;
37208 fail:
37209 return NULL;
37210 }
37211
37212
37213 SWIGINTERN PyObject *_wrap_StandardPaths_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37214 PyObject *resultobj = 0;
37215 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37216 wxString result;
37217 void *argp1 = 0 ;
37218 int res1 = 0 ;
37219 PyObject *swig_obj[1] ;
37220
37221 if (!args) SWIG_fail;
37222 swig_obj[0] = args;
37223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37224 if (!SWIG_IsOK(res1)) {
37225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetTempDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37226 }
37227 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37228 {
37229 PyThreadState* __tstate = wxPyBeginAllowThreads();
37230 result = ((wxStandardPaths const *)arg1)->GetTempDir();
37231 wxPyEndAllowThreads(__tstate);
37232 if (PyErr_Occurred()) SWIG_fail;
37233 }
37234 {
37235 #if wxUSE_UNICODE
37236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37237 #else
37238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37239 #endif
37240 }
37241 return resultobj;
37242 fail:
37243 return NULL;
37244 }
37245
37246
37247 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37248 PyObject *resultobj = 0;
37249 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37250 wxString *arg2 = 0 ;
37251 void *argp1 = 0 ;
37252 int res1 = 0 ;
37253 bool temp2 = false ;
37254 PyObject * obj0 = 0 ;
37255 PyObject * obj1 = 0 ;
37256 char * kwnames[] = {
37257 (char *) "self",(char *) "prefix", NULL
37258 };
37259
37260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
37261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37262 if (!SWIG_IsOK(res1)) {
37263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
37264 }
37265 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37266 {
37267 arg2 = wxString_in_helper(obj1);
37268 if (arg2 == NULL) SWIG_fail;
37269 temp2 = true;
37270 }
37271 {
37272 PyThreadState* __tstate = wxPyBeginAllowThreads();
37273 (arg1)->SetInstallPrefix((wxString const &)*arg2);
37274 wxPyEndAllowThreads(__tstate);
37275 if (PyErr_Occurred()) SWIG_fail;
37276 }
37277 resultobj = SWIG_Py_Void();
37278 {
37279 if (temp2)
37280 delete arg2;
37281 }
37282 return resultobj;
37283 fail:
37284 {
37285 if (temp2)
37286 delete arg2;
37287 }
37288 return NULL;
37289 }
37290
37291
37292 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37293 PyObject *resultobj = 0;
37294 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
37295 wxString result;
37296 void *argp1 = 0 ;
37297 int res1 = 0 ;
37298 PyObject *swig_obj[1] ;
37299
37300 if (!args) SWIG_fail;
37301 swig_obj[0] = args;
37302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
37303 if (!SWIG_IsOK(res1)) {
37304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
37305 }
37306 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
37307 {
37308 PyThreadState* __tstate = wxPyBeginAllowThreads();
37309 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
37310 wxPyEndAllowThreads(__tstate);
37311 if (PyErr_Occurred()) SWIG_fail;
37312 }
37313 {
37314 #if wxUSE_UNICODE
37315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37316 #else
37317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37318 #endif
37319 }
37320 return resultobj;
37321 fail:
37322 return NULL;
37323 }
37324
37325
37326 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37327 PyObject *obj;
37328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37329 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
37330 return SWIG_Py_Void();
37331 }
37332
37333 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37334 PyObject *resultobj = 0;
37335 wxEventType arg1 ;
37336 wxPowerEvent *result = 0 ;
37337 int val1 ;
37338 int ecode1 = 0 ;
37339 PyObject * obj0 = 0 ;
37340 char * kwnames[] = {
37341 (char *) "evtType", NULL
37342 };
37343
37344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
37345 ecode1 = SWIG_AsVal_int(obj0, &val1);
37346 if (!SWIG_IsOK(ecode1)) {
37347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
37348 }
37349 arg1 = static_cast< wxEventType >(val1);
37350 {
37351 PyThreadState* __tstate = wxPyBeginAllowThreads();
37352 result = (wxPowerEvent *)new wxPowerEvent(arg1);
37353 wxPyEndAllowThreads(__tstate);
37354 if (PyErr_Occurred()) SWIG_fail;
37355 }
37356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
37357 return resultobj;
37358 fail:
37359 return NULL;
37360 }
37361
37362
37363 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37364 PyObject *resultobj = 0;
37365 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37366 void *argp1 = 0 ;
37367 int res1 = 0 ;
37368 PyObject *swig_obj[1] ;
37369
37370 if (!args) SWIG_fail;
37371 swig_obj[0] = args;
37372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37373 if (!SWIG_IsOK(res1)) {
37374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
37375 }
37376 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37377 {
37378 PyThreadState* __tstate = wxPyBeginAllowThreads();
37379 (arg1)->Veto();
37380 wxPyEndAllowThreads(__tstate);
37381 if (PyErr_Occurred()) SWIG_fail;
37382 }
37383 resultobj = SWIG_Py_Void();
37384 return resultobj;
37385 fail:
37386 return NULL;
37387 }
37388
37389
37390 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37391 PyObject *resultobj = 0;
37392 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
37393 bool result;
37394 void *argp1 = 0 ;
37395 int res1 = 0 ;
37396 PyObject *swig_obj[1] ;
37397
37398 if (!args) SWIG_fail;
37399 swig_obj[0] = args;
37400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
37401 if (!SWIG_IsOK(res1)) {
37402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
37403 }
37404 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
37405 {
37406 PyThreadState* __tstate = wxPyBeginAllowThreads();
37407 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
37408 wxPyEndAllowThreads(__tstate);
37409 if (PyErr_Occurred()) SWIG_fail;
37410 }
37411 {
37412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37413 }
37414 return resultobj;
37415 fail:
37416 return NULL;
37417 }
37418
37419
37420 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37421 PyObject *obj;
37422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37423 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
37424 return SWIG_Py_Void();
37425 }
37426
37427 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37428 return SWIG_Python_InitShadowInstance(args);
37429 }
37430
37431 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37432 PyObject *resultobj = 0;
37433 wxPowerType result;
37434
37435 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
37436 {
37437 PyThreadState* __tstate = wxPyBeginAllowThreads();
37438 result = (wxPowerType)wxGetPowerType();
37439 wxPyEndAllowThreads(__tstate);
37440 if (PyErr_Occurred()) SWIG_fail;
37441 }
37442 resultobj = SWIG_From_int(static_cast< int >(result));
37443 return resultobj;
37444 fail:
37445 return NULL;
37446 }
37447
37448
37449 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37450 PyObject *resultobj = 0;
37451 wxBatteryState result;
37452
37453 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
37454 {
37455 PyThreadState* __tstate = wxPyBeginAllowThreads();
37456 result = (wxBatteryState)wxGetBatteryState();
37457 wxPyEndAllowThreads(__tstate);
37458 if (PyErr_Occurred()) SWIG_fail;
37459 }
37460 resultobj = SWIG_From_int(static_cast< int >(result));
37461 return resultobj;
37462 fail:
37463 return NULL;
37464 }
37465
37466
37467 SWIGINTERN PyObject *_wrap_new_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37468 PyObject *resultobj = 0;
37469 wxAboutDialogInfo *result = 0 ;
37470
37471 if (!SWIG_Python_UnpackTuple(args,"new_AboutDialogInfo",0,0,0)) SWIG_fail;
37472 {
37473 PyThreadState* __tstate = wxPyBeginAllowThreads();
37474 result = (wxAboutDialogInfo *)new wxAboutDialogInfo();
37475 wxPyEndAllowThreads(__tstate);
37476 if (PyErr_Occurred()) SWIG_fail;
37477 }
37478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_NEW | 0 );
37479 return resultobj;
37480 fail:
37481 return NULL;
37482 }
37483
37484
37485 SWIGINTERN PyObject *_wrap_delete_AboutDialogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37486 PyObject *resultobj = 0;
37487 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37488 void *argp1 = 0 ;
37489 int res1 = 0 ;
37490 PyObject *swig_obj[1] ;
37491
37492 if (!args) SWIG_fail;
37493 swig_obj[0] = args;
37494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, SWIG_POINTER_DISOWN | 0 );
37495 if (!SWIG_IsOK(res1)) {
37496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AboutDialogInfo" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37497 }
37498 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37499 {
37500 PyThreadState* __tstate = wxPyBeginAllowThreads();
37501 delete arg1;
37502
37503 wxPyEndAllowThreads(__tstate);
37504 if (PyErr_Occurred()) SWIG_fail;
37505 }
37506 resultobj = SWIG_Py_Void();
37507 return resultobj;
37508 fail:
37509 return NULL;
37510 }
37511
37512
37513 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37514 PyObject *resultobj = 0;
37515 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37516 wxString *arg2 = 0 ;
37517 void *argp1 = 0 ;
37518 int res1 = 0 ;
37519 bool temp2 = false ;
37520 PyObject * obj0 = 0 ;
37521 PyObject * obj1 = 0 ;
37522 char * kwnames[] = {
37523 (char *) "self",(char *) "name", NULL
37524 };
37525
37526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
37527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37528 if (!SWIG_IsOK(res1)) {
37529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37530 }
37531 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37532 {
37533 arg2 = wxString_in_helper(obj1);
37534 if (arg2 == NULL) SWIG_fail;
37535 temp2 = true;
37536 }
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 (arg1)->SetName((wxString const &)*arg2);
37540 wxPyEndAllowThreads(__tstate);
37541 if (PyErr_Occurred()) SWIG_fail;
37542 }
37543 resultobj = SWIG_Py_Void();
37544 {
37545 if (temp2)
37546 delete arg2;
37547 }
37548 return resultobj;
37549 fail:
37550 {
37551 if (temp2)
37552 delete arg2;
37553 }
37554 return NULL;
37555 }
37556
37557
37558 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37559 PyObject *resultobj = 0;
37560 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37561 wxString result;
37562 void *argp1 = 0 ;
37563 int res1 = 0 ;
37564 PyObject *swig_obj[1] ;
37565
37566 if (!args) SWIG_fail;
37567 swig_obj[0] = args;
37568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37569 if (!SWIG_IsOK(res1)) {
37570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetName" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37571 }
37572 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37573 {
37574 PyThreadState* __tstate = wxPyBeginAllowThreads();
37575 result = ((wxAboutDialogInfo const *)arg1)->GetName();
37576 wxPyEndAllowThreads(__tstate);
37577 if (PyErr_Occurred()) SWIG_fail;
37578 }
37579 {
37580 #if wxUSE_UNICODE
37581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37582 #else
37583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37584 #endif
37585 }
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37593 PyObject *resultobj = 0;
37594 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37595 wxString *arg2 = 0 ;
37596 void *argp1 = 0 ;
37597 int res1 = 0 ;
37598 bool temp2 = false ;
37599 PyObject * obj0 = 0 ;
37600 PyObject * obj1 = 0 ;
37601 char * kwnames[] = {
37602 (char *) "self",(char *) "version", NULL
37603 };
37604
37605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetVersion",kwnames,&obj0,&obj1)) SWIG_fail;
37606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37607 if (!SWIG_IsOK(res1)) {
37608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37609 }
37610 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37611 {
37612 arg2 = wxString_in_helper(obj1);
37613 if (arg2 == NULL) SWIG_fail;
37614 temp2 = true;
37615 }
37616 {
37617 PyThreadState* __tstate = wxPyBeginAllowThreads();
37618 (arg1)->SetVersion((wxString const &)*arg2);
37619 wxPyEndAllowThreads(__tstate);
37620 if (PyErr_Occurred()) SWIG_fail;
37621 }
37622 resultobj = SWIG_Py_Void();
37623 {
37624 if (temp2)
37625 delete arg2;
37626 }
37627 return resultobj;
37628 fail:
37629 {
37630 if (temp2)
37631 delete arg2;
37632 }
37633 return NULL;
37634 }
37635
37636
37637 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37638 PyObject *resultobj = 0;
37639 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37640 bool result;
37641 void *argp1 = 0 ;
37642 int res1 = 0 ;
37643 PyObject *swig_obj[1] ;
37644
37645 if (!args) SWIG_fail;
37646 swig_obj[0] = args;
37647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37648 if (!SWIG_IsOK(res1)) {
37649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37650 }
37651 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37652 {
37653 PyThreadState* __tstate = wxPyBeginAllowThreads();
37654 result = (bool)((wxAboutDialogInfo const *)arg1)->HasVersion();
37655 wxPyEndAllowThreads(__tstate);
37656 if (PyErr_Occurred()) SWIG_fail;
37657 }
37658 {
37659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37660 }
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37668 PyObject *resultobj = 0;
37669 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37670 wxString result;
37671 void *argp1 = 0 ;
37672 int res1 = 0 ;
37673 PyObject *swig_obj[1] ;
37674
37675 if (!args) SWIG_fail;
37676 swig_obj[0] = args;
37677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37678 if (!SWIG_IsOK(res1)) {
37679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetVersion" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37680 }
37681 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37682 {
37683 PyThreadState* __tstate = wxPyBeginAllowThreads();
37684 result = ((wxAboutDialogInfo const *)arg1)->GetVersion();
37685 wxPyEndAllowThreads(__tstate);
37686 if (PyErr_Occurred()) SWIG_fail;
37687 }
37688 {
37689 #if wxUSE_UNICODE
37690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37691 #else
37692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37693 #endif
37694 }
37695 return resultobj;
37696 fail:
37697 return NULL;
37698 }
37699
37700
37701 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37702 PyObject *resultobj = 0;
37703 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37704 wxString *arg2 = 0 ;
37705 void *argp1 = 0 ;
37706 int res1 = 0 ;
37707 bool temp2 = false ;
37708 PyObject * obj0 = 0 ;
37709 PyObject * obj1 = 0 ;
37710 char * kwnames[] = {
37711 (char *) "self",(char *) "desc", NULL
37712 };
37713
37714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDescription",kwnames,&obj0,&obj1)) SWIG_fail;
37715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37716 if (!SWIG_IsOK(res1)) {
37717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37718 }
37719 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37720 {
37721 arg2 = wxString_in_helper(obj1);
37722 if (arg2 == NULL) SWIG_fail;
37723 temp2 = true;
37724 }
37725 {
37726 PyThreadState* __tstate = wxPyBeginAllowThreads();
37727 (arg1)->SetDescription((wxString const &)*arg2);
37728 wxPyEndAllowThreads(__tstate);
37729 if (PyErr_Occurred()) SWIG_fail;
37730 }
37731 resultobj = SWIG_Py_Void();
37732 {
37733 if (temp2)
37734 delete arg2;
37735 }
37736 return resultobj;
37737 fail:
37738 {
37739 if (temp2)
37740 delete arg2;
37741 }
37742 return NULL;
37743 }
37744
37745
37746 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37747 PyObject *resultobj = 0;
37748 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37749 bool result;
37750 void *argp1 = 0 ;
37751 int res1 = 0 ;
37752 PyObject *swig_obj[1] ;
37753
37754 if (!args) SWIG_fail;
37755 swig_obj[0] = args;
37756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37757 if (!SWIG_IsOK(res1)) {
37758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37759 }
37760 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37761 {
37762 PyThreadState* __tstate = wxPyBeginAllowThreads();
37763 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDescription();
37764 wxPyEndAllowThreads(__tstate);
37765 if (PyErr_Occurred()) SWIG_fail;
37766 }
37767 {
37768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37769 }
37770 return resultobj;
37771 fail:
37772 return NULL;
37773 }
37774
37775
37776 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37777 PyObject *resultobj = 0;
37778 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37779 wxString result;
37780 void *argp1 = 0 ;
37781 int res1 = 0 ;
37782 PyObject *swig_obj[1] ;
37783
37784 if (!args) SWIG_fail;
37785 swig_obj[0] = args;
37786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37787 if (!SWIG_IsOK(res1)) {
37788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37789 }
37790 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37791 {
37792 PyThreadState* __tstate = wxPyBeginAllowThreads();
37793 result = ((wxAboutDialogInfo const *)arg1)->GetDescription();
37794 wxPyEndAllowThreads(__tstate);
37795 if (PyErr_Occurred()) SWIG_fail;
37796 }
37797 {
37798 #if wxUSE_UNICODE
37799 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37800 #else
37801 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37802 #endif
37803 }
37804 return resultobj;
37805 fail:
37806 return NULL;
37807 }
37808
37809
37810 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37811 PyObject *resultobj = 0;
37812 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37813 wxString *arg2 = 0 ;
37814 void *argp1 = 0 ;
37815 int res1 = 0 ;
37816 bool temp2 = false ;
37817 PyObject * obj0 = 0 ;
37818 PyObject * obj1 = 0 ;
37819 char * kwnames[] = {
37820 (char *) "self",(char *) "copyright", NULL
37821 };
37822
37823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetCopyright",kwnames,&obj0,&obj1)) SWIG_fail;
37824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37825 if (!SWIG_IsOK(res1)) {
37826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37827 }
37828 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37829 {
37830 arg2 = wxString_in_helper(obj1);
37831 if (arg2 == NULL) SWIG_fail;
37832 temp2 = true;
37833 }
37834 {
37835 PyThreadState* __tstate = wxPyBeginAllowThreads();
37836 (arg1)->SetCopyright((wxString const &)*arg2);
37837 wxPyEndAllowThreads(__tstate);
37838 if (PyErr_Occurred()) SWIG_fail;
37839 }
37840 resultobj = SWIG_Py_Void();
37841 {
37842 if (temp2)
37843 delete arg2;
37844 }
37845 return resultobj;
37846 fail:
37847 {
37848 if (temp2)
37849 delete arg2;
37850 }
37851 return NULL;
37852 }
37853
37854
37855 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37856 PyObject *resultobj = 0;
37857 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37858 bool result;
37859 void *argp1 = 0 ;
37860 int res1 = 0 ;
37861 PyObject *swig_obj[1] ;
37862
37863 if (!args) SWIG_fail;
37864 swig_obj[0] = args;
37865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37866 if (!SWIG_IsOK(res1)) {
37867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37868 }
37869 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 result = (bool)((wxAboutDialogInfo const *)arg1)->HasCopyright();
37873 wxPyEndAllowThreads(__tstate);
37874 if (PyErr_Occurred()) SWIG_fail;
37875 }
37876 {
37877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37878 }
37879 return resultobj;
37880 fail:
37881 return NULL;
37882 }
37883
37884
37885 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetCopyright(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37886 PyObject *resultobj = 0;
37887 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37888 wxString result;
37889 void *argp1 = 0 ;
37890 int res1 = 0 ;
37891 PyObject *swig_obj[1] ;
37892
37893 if (!args) SWIG_fail;
37894 swig_obj[0] = args;
37895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37896 if (!SWIG_IsOK(res1)) {
37897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetCopyright" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
37898 }
37899 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37900 {
37901 PyThreadState* __tstate = wxPyBeginAllowThreads();
37902 result = ((wxAboutDialogInfo const *)arg1)->GetCopyright();
37903 wxPyEndAllowThreads(__tstate);
37904 if (PyErr_Occurred()) SWIG_fail;
37905 }
37906 {
37907 #if wxUSE_UNICODE
37908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37909 #else
37910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37911 #endif
37912 }
37913 return resultobj;
37914 fail:
37915 return NULL;
37916 }
37917
37918
37919 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37920 PyObject *resultobj = 0;
37921 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37922 wxString *arg2 = 0 ;
37923 void *argp1 = 0 ;
37924 int res1 = 0 ;
37925 bool temp2 = false ;
37926 PyObject * obj0 = 0 ;
37927 PyObject * obj1 = 0 ;
37928 char * kwnames[] = {
37929 (char *) "self",(char *) "licence", NULL
37930 };
37931
37932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicence",kwnames,&obj0,&obj1)) SWIG_fail;
37933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37934 if (!SWIG_IsOK(res1)) {
37935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37936 }
37937 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37938 {
37939 arg2 = wxString_in_helper(obj1);
37940 if (arg2 == NULL) SWIG_fail;
37941 temp2 = true;
37942 }
37943 {
37944 PyThreadState* __tstate = wxPyBeginAllowThreads();
37945 (arg1)->SetLicence((wxString const &)*arg2);
37946 wxPyEndAllowThreads(__tstate);
37947 if (PyErr_Occurred()) SWIG_fail;
37948 }
37949 resultobj = SWIG_Py_Void();
37950 {
37951 if (temp2)
37952 delete arg2;
37953 }
37954 return resultobj;
37955 fail:
37956 {
37957 if (temp2)
37958 delete arg2;
37959 }
37960 return NULL;
37961 }
37962
37963
37964 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetLicense(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37965 PyObject *resultobj = 0;
37966 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
37967 wxString *arg2 = 0 ;
37968 void *argp1 = 0 ;
37969 int res1 = 0 ;
37970 bool temp2 = false ;
37971 PyObject * obj0 = 0 ;
37972 PyObject * obj1 = 0 ;
37973 char * kwnames[] = {
37974 (char *) "self",(char *) "licence", NULL
37975 };
37976
37977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetLicense",kwnames,&obj0,&obj1)) SWIG_fail;
37978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
37979 if (!SWIG_IsOK(res1)) {
37980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetLicense" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
37981 }
37982 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
37983 {
37984 arg2 = wxString_in_helper(obj1);
37985 if (arg2 == NULL) SWIG_fail;
37986 temp2 = true;
37987 }
37988 {
37989 PyThreadState* __tstate = wxPyBeginAllowThreads();
37990 (arg1)->SetLicense((wxString const &)*arg2);
37991 wxPyEndAllowThreads(__tstate);
37992 if (PyErr_Occurred()) SWIG_fail;
37993 }
37994 resultobj = SWIG_Py_Void();
37995 {
37996 if (temp2)
37997 delete arg2;
37998 }
37999 return resultobj;
38000 fail:
38001 {
38002 if (temp2)
38003 delete arg2;
38004 }
38005 return NULL;
38006 }
38007
38008
38009 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38010 PyObject *resultobj = 0;
38011 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38012 bool result;
38013 void *argp1 = 0 ;
38014 int res1 = 0 ;
38015 PyObject *swig_obj[1] ;
38016
38017 if (!args) SWIG_fail;
38018 swig_obj[0] = args;
38019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38020 if (!SWIG_IsOK(res1)) {
38021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38022 }
38023 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38024 {
38025 PyThreadState* __tstate = wxPyBeginAllowThreads();
38026 result = (bool)((wxAboutDialogInfo const *)arg1)->HasLicence();
38027 wxPyEndAllowThreads(__tstate);
38028 if (PyErr_Occurred()) SWIG_fail;
38029 }
38030 {
38031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38032 }
38033 return resultobj;
38034 fail:
38035 return NULL;
38036 }
38037
38038
38039 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetLicence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38040 PyObject *resultobj = 0;
38041 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38042 wxString result;
38043 void *argp1 = 0 ;
38044 int res1 = 0 ;
38045 PyObject *swig_obj[1] ;
38046
38047 if (!args) SWIG_fail;
38048 swig_obj[0] = args;
38049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38050 if (!SWIG_IsOK(res1)) {
38051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetLicence" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38052 }
38053 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38054 {
38055 PyThreadState* __tstate = wxPyBeginAllowThreads();
38056 result = ((wxAboutDialogInfo const *)arg1)->GetLicence();
38057 wxPyEndAllowThreads(__tstate);
38058 if (PyErr_Occurred()) SWIG_fail;
38059 }
38060 {
38061 #if wxUSE_UNICODE
38062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38063 #else
38064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38065 #endif
38066 }
38067 return resultobj;
38068 fail:
38069 return NULL;
38070 }
38071
38072
38073 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38074 PyObject *resultobj = 0;
38075 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38076 wxIcon *arg2 = 0 ;
38077 void *argp1 = 0 ;
38078 int res1 = 0 ;
38079 void *argp2 = 0 ;
38080 int res2 = 0 ;
38081 PyObject * obj0 = 0 ;
38082 PyObject * obj1 = 0 ;
38083 char * kwnames[] = {
38084 (char *) "self",(char *) "icon", NULL
38085 };
38086
38087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetIcon",kwnames,&obj0,&obj1)) SWIG_fail;
38088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38089 if (!SWIG_IsOK(res1)) {
38090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38091 }
38092 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
38094 if (!SWIG_IsOK(res2)) {
38095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38096 }
38097 if (!argp2) {
38098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutDialogInfo_SetIcon" "', expected argument " "2"" of type '" "wxIcon const &""'");
38099 }
38100 arg2 = reinterpret_cast< wxIcon * >(argp2);
38101 {
38102 PyThreadState* __tstate = wxPyBeginAllowThreads();
38103 (arg1)->SetIcon((wxIcon const &)*arg2);
38104 wxPyEndAllowThreads(__tstate);
38105 if (PyErr_Occurred()) SWIG_fail;
38106 }
38107 resultobj = SWIG_Py_Void();
38108 return resultobj;
38109 fail:
38110 return NULL;
38111 }
38112
38113
38114 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38115 PyObject *resultobj = 0;
38116 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38117 bool result;
38118 void *argp1 = 0 ;
38119 int res1 = 0 ;
38120 PyObject *swig_obj[1] ;
38121
38122 if (!args) SWIG_fail;
38123 swig_obj[0] = args;
38124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38125 if (!SWIG_IsOK(res1)) {
38126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38127 }
38128 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38129 {
38130 PyThreadState* __tstate = wxPyBeginAllowThreads();
38131 result = (bool)((wxAboutDialogInfo const *)arg1)->HasIcon();
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 {
38136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38137 }
38138 return resultobj;
38139 fail:
38140 return NULL;
38141 }
38142
38143
38144 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38145 PyObject *resultobj = 0;
38146 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38147 wxIcon result;
38148 void *argp1 = 0 ;
38149 int res1 = 0 ;
38150 PyObject *swig_obj[1] ;
38151
38152 if (!args) SWIG_fail;
38153 swig_obj[0] = args;
38154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38155 if (!SWIG_IsOK(res1)) {
38156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetIcon" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38157 }
38158 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38159 {
38160 PyThreadState* __tstate = wxPyBeginAllowThreads();
38161 result = ((wxAboutDialogInfo const *)arg1)->GetIcon();
38162 wxPyEndAllowThreads(__tstate);
38163 if (PyErr_Occurred()) SWIG_fail;
38164 }
38165 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
38166 return resultobj;
38167 fail:
38168 return NULL;
38169 }
38170
38171
38172 SWIGINTERN PyObject *_wrap_AboutDialogInfo__SetWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38173 PyObject *resultobj = 0;
38174 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38175 wxString *arg2 = 0 ;
38176 wxString const &arg3_defvalue = wxEmptyString ;
38177 wxString *arg3 = (wxString *) &arg3_defvalue ;
38178 void *argp1 = 0 ;
38179 int res1 = 0 ;
38180 bool temp2 = false ;
38181 bool temp3 = false ;
38182 PyObject * obj0 = 0 ;
38183 PyObject * obj1 = 0 ;
38184 PyObject * obj2 = 0 ;
38185 char * kwnames[] = {
38186 (char *) "self",(char *) "url",(char *) "desc", NULL
38187 };
38188
38189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:AboutDialogInfo__SetWebSite",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38191 if (!SWIG_IsOK(res1)) {
38192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__SetWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38193 }
38194 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38195 {
38196 arg2 = wxString_in_helper(obj1);
38197 if (arg2 == NULL) SWIG_fail;
38198 temp2 = true;
38199 }
38200 if (obj2) {
38201 {
38202 arg3 = wxString_in_helper(obj2);
38203 if (arg3 == NULL) SWIG_fail;
38204 temp3 = true;
38205 }
38206 }
38207 {
38208 PyThreadState* __tstate = wxPyBeginAllowThreads();
38209 (arg1)->SetWebSite((wxString const &)*arg2,(wxString const &)*arg3);
38210 wxPyEndAllowThreads(__tstate);
38211 if (PyErr_Occurred()) SWIG_fail;
38212 }
38213 resultobj = SWIG_Py_Void();
38214 {
38215 if (temp2)
38216 delete arg2;
38217 }
38218 {
38219 if (temp3)
38220 delete arg3;
38221 }
38222 return resultobj;
38223 fail:
38224 {
38225 if (temp2)
38226 delete arg2;
38227 }
38228 {
38229 if (temp3)
38230 delete arg3;
38231 }
38232 return NULL;
38233 }
38234
38235
38236 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38237 PyObject *resultobj = 0;
38238 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38239 wxString result;
38240 void *argp1 = 0 ;
38241 int res1 = 0 ;
38242 PyObject *swig_obj[1] ;
38243
38244 if (!args) SWIG_fail;
38245 swig_obj[0] = args;
38246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38247 if (!SWIG_IsOK(res1)) {
38248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteURL" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38249 }
38250 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38251 {
38252 PyThreadState* __tstate = wxPyBeginAllowThreads();
38253 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteURL();
38254 wxPyEndAllowThreads(__tstate);
38255 if (PyErr_Occurred()) SWIG_fail;
38256 }
38257 {
38258 #if wxUSE_UNICODE
38259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38260 #else
38261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38262 #endif
38263 }
38264 return resultobj;
38265 fail:
38266 return NULL;
38267 }
38268
38269
38270 SWIGINTERN PyObject *_wrap_AboutDialogInfo__GetWebSiteDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38271 PyObject *resultobj = 0;
38272 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38273 wxString result;
38274 void *argp1 = 0 ;
38275 int res1 = 0 ;
38276 PyObject *swig_obj[1] ;
38277
38278 if (!args) SWIG_fail;
38279 swig_obj[0] = args;
38280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38281 if (!SWIG_IsOK(res1)) {
38282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo__GetWebSiteDescription" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38283 }
38284 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38285 {
38286 PyThreadState* __tstate = wxPyBeginAllowThreads();
38287 result = ((wxAboutDialogInfo const *)arg1)->GetWebSiteDescription();
38288 wxPyEndAllowThreads(__tstate);
38289 if (PyErr_Occurred()) SWIG_fail;
38290 }
38291 {
38292 #if wxUSE_UNICODE
38293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38294 #else
38295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38296 #endif
38297 }
38298 return resultobj;
38299 fail:
38300 return NULL;
38301 }
38302
38303
38304 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasWebSite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38305 PyObject *resultobj = 0;
38306 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38307 bool result;
38308 void *argp1 = 0 ;
38309 int res1 = 0 ;
38310 PyObject *swig_obj[1] ;
38311
38312 if (!args) SWIG_fail;
38313 swig_obj[0] = args;
38314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38315 if (!SWIG_IsOK(res1)) {
38316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasWebSite" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38317 }
38318 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38319 {
38320 PyThreadState* __tstate = wxPyBeginAllowThreads();
38321 result = (bool)((wxAboutDialogInfo const *)arg1)->HasWebSite();
38322 wxPyEndAllowThreads(__tstate);
38323 if (PyErr_Occurred()) SWIG_fail;
38324 }
38325 {
38326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38327 }
38328 return resultobj;
38329 fail:
38330 return NULL;
38331 }
38332
38333
38334 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38335 PyObject *resultobj = 0;
38336 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38337 wxArrayString *arg2 = 0 ;
38338 void *argp1 = 0 ;
38339 int res1 = 0 ;
38340 bool temp2 = false ;
38341 PyObject * obj0 = 0 ;
38342 PyObject * obj1 = 0 ;
38343 char * kwnames[] = {
38344 (char *) "self",(char *) "developers", NULL
38345 };
38346
38347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDevelopers",kwnames,&obj0,&obj1)) SWIG_fail;
38348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38349 if (!SWIG_IsOK(res1)) {
38350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38351 }
38352 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38353 {
38354 if (! PySequence_Check(obj1)) {
38355 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38356 SWIG_fail;
38357 }
38358 arg2 = new wxArrayString;
38359 temp2 = true;
38360 int i, len=PySequence_Length(obj1);
38361 for (i=0; i<len; i++) {
38362 PyObject* item = PySequence_GetItem(obj1, i);
38363 wxString* s = wxString_in_helper(item);
38364 if (PyErr_Occurred()) SWIG_fail;
38365 arg2->Add(*s);
38366 delete s;
38367 Py_DECREF(item);
38368 }
38369 }
38370 {
38371 PyThreadState* __tstate = wxPyBeginAllowThreads();
38372 (arg1)->SetDevelopers((wxArrayString const &)*arg2);
38373 wxPyEndAllowThreads(__tstate);
38374 if (PyErr_Occurred()) SWIG_fail;
38375 }
38376 resultobj = SWIG_Py_Void();
38377 {
38378 if (temp2) delete arg2;
38379 }
38380 return resultobj;
38381 fail:
38382 {
38383 if (temp2) delete arg2;
38384 }
38385 return NULL;
38386 }
38387
38388
38389 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDeveloper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38390 PyObject *resultobj = 0;
38391 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38392 wxString *arg2 = 0 ;
38393 void *argp1 = 0 ;
38394 int res1 = 0 ;
38395 bool temp2 = false ;
38396 PyObject * obj0 = 0 ;
38397 PyObject * obj1 = 0 ;
38398 char * kwnames[] = {
38399 (char *) "self",(char *) "developer", NULL
38400 };
38401
38402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDeveloper",kwnames,&obj0,&obj1)) SWIG_fail;
38403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38404 if (!SWIG_IsOK(res1)) {
38405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDeveloper" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38406 }
38407 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38408 {
38409 arg2 = wxString_in_helper(obj1);
38410 if (arg2 == NULL) SWIG_fail;
38411 temp2 = true;
38412 }
38413 {
38414 PyThreadState* __tstate = wxPyBeginAllowThreads();
38415 (arg1)->AddDeveloper((wxString const &)*arg2);
38416 wxPyEndAllowThreads(__tstate);
38417 if (PyErr_Occurred()) SWIG_fail;
38418 }
38419 resultobj = SWIG_Py_Void();
38420 {
38421 if (temp2)
38422 delete arg2;
38423 }
38424 return resultobj;
38425 fail:
38426 {
38427 if (temp2)
38428 delete arg2;
38429 }
38430 return NULL;
38431 }
38432
38433
38434 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38435 PyObject *resultobj = 0;
38436 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38437 bool result;
38438 void *argp1 = 0 ;
38439 int res1 = 0 ;
38440 PyObject *swig_obj[1] ;
38441
38442 if (!args) SWIG_fail;
38443 swig_obj[0] = args;
38444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38445 if (!SWIG_IsOK(res1)) {
38446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38447 }
38448 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38449 {
38450 PyThreadState* __tstate = wxPyBeginAllowThreads();
38451 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDevelopers();
38452 wxPyEndAllowThreads(__tstate);
38453 if (PyErr_Occurred()) SWIG_fail;
38454 }
38455 {
38456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38457 }
38458 return resultobj;
38459 fail:
38460 return NULL;
38461 }
38462
38463
38464 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDevelopers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38465 PyObject *resultobj = 0;
38466 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38467 wxArrayString *result = 0 ;
38468 void *argp1 = 0 ;
38469 int res1 = 0 ;
38470 PyObject *swig_obj[1] ;
38471
38472 if (!args) SWIG_fail;
38473 swig_obj[0] = args;
38474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38475 if (!SWIG_IsOK(res1)) {
38476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDevelopers" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38477 }
38478 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38479 {
38480 PyThreadState* __tstate = wxPyBeginAllowThreads();
38481 {
38482 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDevelopers();
38483 result = (wxArrayString *) &_result_ref;
38484 }
38485 wxPyEndAllowThreads(__tstate);
38486 if (PyErr_Occurred()) SWIG_fail;
38487 }
38488 {
38489 resultobj = wxArrayString2PyList_helper(*result);
38490 }
38491 return resultobj;
38492 fail:
38493 return NULL;
38494 }
38495
38496
38497 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38498 PyObject *resultobj = 0;
38499 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38500 wxArrayString *arg2 = 0 ;
38501 void *argp1 = 0 ;
38502 int res1 = 0 ;
38503 bool temp2 = false ;
38504 PyObject * obj0 = 0 ;
38505 PyObject * obj1 = 0 ;
38506 char * kwnames[] = {
38507 (char *) "self",(char *) "docwriters", NULL
38508 };
38509
38510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetDocWriters",kwnames,&obj0,&obj1)) SWIG_fail;
38511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38512 if (!SWIG_IsOK(res1)) {
38513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38514 }
38515 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38516 {
38517 if (! PySequence_Check(obj1)) {
38518 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38519 SWIG_fail;
38520 }
38521 arg2 = new wxArrayString;
38522 temp2 = true;
38523 int i, len=PySequence_Length(obj1);
38524 for (i=0; i<len; i++) {
38525 PyObject* item = PySequence_GetItem(obj1, i);
38526 wxString* s = wxString_in_helper(item);
38527 if (PyErr_Occurred()) SWIG_fail;
38528 arg2->Add(*s);
38529 delete s;
38530 Py_DECREF(item);
38531 }
38532 }
38533 {
38534 PyThreadState* __tstate = wxPyBeginAllowThreads();
38535 (arg1)->SetDocWriters((wxArrayString const &)*arg2);
38536 wxPyEndAllowThreads(__tstate);
38537 if (PyErr_Occurred()) SWIG_fail;
38538 }
38539 resultobj = SWIG_Py_Void();
38540 {
38541 if (temp2) delete arg2;
38542 }
38543 return resultobj;
38544 fail:
38545 {
38546 if (temp2) delete arg2;
38547 }
38548 return NULL;
38549 }
38550
38551
38552 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddDocWriter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38553 PyObject *resultobj = 0;
38554 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38555 wxString *arg2 = 0 ;
38556 void *argp1 = 0 ;
38557 int res1 = 0 ;
38558 bool temp2 = false ;
38559 PyObject * obj0 = 0 ;
38560 PyObject * obj1 = 0 ;
38561 char * kwnames[] = {
38562 (char *) "self",(char *) "docwriter", NULL
38563 };
38564
38565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddDocWriter",kwnames,&obj0,&obj1)) SWIG_fail;
38566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38567 if (!SWIG_IsOK(res1)) {
38568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddDocWriter" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38569 }
38570 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38571 {
38572 arg2 = wxString_in_helper(obj1);
38573 if (arg2 == NULL) SWIG_fail;
38574 temp2 = true;
38575 }
38576 {
38577 PyThreadState* __tstate = wxPyBeginAllowThreads();
38578 (arg1)->AddDocWriter((wxString const &)*arg2);
38579 wxPyEndAllowThreads(__tstate);
38580 if (PyErr_Occurred()) SWIG_fail;
38581 }
38582 resultobj = SWIG_Py_Void();
38583 {
38584 if (temp2)
38585 delete arg2;
38586 }
38587 return resultobj;
38588 fail:
38589 {
38590 if (temp2)
38591 delete arg2;
38592 }
38593 return NULL;
38594 }
38595
38596
38597 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38598 PyObject *resultobj = 0;
38599 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38600 bool result;
38601 void *argp1 = 0 ;
38602 int res1 = 0 ;
38603 PyObject *swig_obj[1] ;
38604
38605 if (!args) SWIG_fail;
38606 swig_obj[0] = args;
38607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38608 if (!SWIG_IsOK(res1)) {
38609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38610 }
38611 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38612 {
38613 PyThreadState* __tstate = wxPyBeginAllowThreads();
38614 result = (bool)((wxAboutDialogInfo const *)arg1)->HasDocWriters();
38615 wxPyEndAllowThreads(__tstate);
38616 if (PyErr_Occurred()) SWIG_fail;
38617 }
38618 {
38619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38620 }
38621 return resultobj;
38622 fail:
38623 return NULL;
38624 }
38625
38626
38627 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDocWriters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38628 PyObject *resultobj = 0;
38629 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38630 wxArrayString *result = 0 ;
38631 void *argp1 = 0 ;
38632 int res1 = 0 ;
38633 PyObject *swig_obj[1] ;
38634
38635 if (!args) SWIG_fail;
38636 swig_obj[0] = args;
38637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38638 if (!SWIG_IsOK(res1)) {
38639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDocWriters" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38640 }
38641 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38642 {
38643 PyThreadState* __tstate = wxPyBeginAllowThreads();
38644 {
38645 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetDocWriters();
38646 result = (wxArrayString *) &_result_ref;
38647 }
38648 wxPyEndAllowThreads(__tstate);
38649 if (PyErr_Occurred()) SWIG_fail;
38650 }
38651 {
38652 resultobj = wxArrayString2PyList_helper(*result);
38653 }
38654 return resultobj;
38655 fail:
38656 return NULL;
38657 }
38658
38659
38660 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38661 PyObject *resultobj = 0;
38662 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38663 wxArrayString *arg2 = 0 ;
38664 void *argp1 = 0 ;
38665 int res1 = 0 ;
38666 bool temp2 = false ;
38667 PyObject * obj0 = 0 ;
38668 PyObject * obj1 = 0 ;
38669 char * kwnames[] = {
38670 (char *) "self",(char *) "artists", NULL
38671 };
38672
38673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetArtists",kwnames,&obj0,&obj1)) SWIG_fail;
38674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38675 if (!SWIG_IsOK(res1)) {
38676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38677 }
38678 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38679 {
38680 if (! PySequence_Check(obj1)) {
38681 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38682 SWIG_fail;
38683 }
38684 arg2 = new wxArrayString;
38685 temp2 = true;
38686 int i, len=PySequence_Length(obj1);
38687 for (i=0; i<len; i++) {
38688 PyObject* item = PySequence_GetItem(obj1, i);
38689 wxString* s = wxString_in_helper(item);
38690 if (PyErr_Occurred()) SWIG_fail;
38691 arg2->Add(*s);
38692 delete s;
38693 Py_DECREF(item);
38694 }
38695 }
38696 {
38697 PyThreadState* __tstate = wxPyBeginAllowThreads();
38698 (arg1)->SetArtists((wxArrayString const &)*arg2);
38699 wxPyEndAllowThreads(__tstate);
38700 if (PyErr_Occurred()) SWIG_fail;
38701 }
38702 resultobj = SWIG_Py_Void();
38703 {
38704 if (temp2) delete arg2;
38705 }
38706 return resultobj;
38707 fail:
38708 {
38709 if (temp2) delete arg2;
38710 }
38711 return NULL;
38712 }
38713
38714
38715 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddArtist(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38716 PyObject *resultobj = 0;
38717 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38718 wxString *arg2 = 0 ;
38719 void *argp1 = 0 ;
38720 int res1 = 0 ;
38721 bool temp2 = false ;
38722 PyObject * obj0 = 0 ;
38723 PyObject * obj1 = 0 ;
38724 char * kwnames[] = {
38725 (char *) "self",(char *) "artist", NULL
38726 };
38727
38728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddArtist",kwnames,&obj0,&obj1)) SWIG_fail;
38729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38730 if (!SWIG_IsOK(res1)) {
38731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddArtist" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38732 }
38733 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38734 {
38735 arg2 = wxString_in_helper(obj1);
38736 if (arg2 == NULL) SWIG_fail;
38737 temp2 = true;
38738 }
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 (arg1)->AddArtist((wxString const &)*arg2);
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 resultobj = SWIG_Py_Void();
38746 {
38747 if (temp2)
38748 delete arg2;
38749 }
38750 return resultobj;
38751 fail:
38752 {
38753 if (temp2)
38754 delete arg2;
38755 }
38756 return NULL;
38757 }
38758
38759
38760 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38761 PyObject *resultobj = 0;
38762 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38763 bool result;
38764 void *argp1 = 0 ;
38765 int res1 = 0 ;
38766 PyObject *swig_obj[1] ;
38767
38768 if (!args) SWIG_fail;
38769 swig_obj[0] = args;
38770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38771 if (!SWIG_IsOK(res1)) {
38772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38773 }
38774 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38775 {
38776 PyThreadState* __tstate = wxPyBeginAllowThreads();
38777 result = (bool)((wxAboutDialogInfo const *)arg1)->HasArtists();
38778 wxPyEndAllowThreads(__tstate);
38779 if (PyErr_Occurred()) SWIG_fail;
38780 }
38781 {
38782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38783 }
38784 return resultobj;
38785 fail:
38786 return NULL;
38787 }
38788
38789
38790 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetArtists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38791 PyObject *resultobj = 0;
38792 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38793 wxArrayString *result = 0 ;
38794 void *argp1 = 0 ;
38795 int res1 = 0 ;
38796 PyObject *swig_obj[1] ;
38797
38798 if (!args) SWIG_fail;
38799 swig_obj[0] = args;
38800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetArtists" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38803 }
38804 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38805 {
38806 PyThreadState* __tstate = wxPyBeginAllowThreads();
38807 {
38808 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetArtists();
38809 result = (wxArrayString *) &_result_ref;
38810 }
38811 wxPyEndAllowThreads(__tstate);
38812 if (PyErr_Occurred()) SWIG_fail;
38813 }
38814 {
38815 resultobj = wxArrayString2PyList_helper(*result);
38816 }
38817 return resultobj;
38818 fail:
38819 return NULL;
38820 }
38821
38822
38823 SWIGINTERN PyObject *_wrap_AboutDialogInfo_SetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38824 PyObject *resultobj = 0;
38825 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38826 wxArrayString *arg2 = 0 ;
38827 void *argp1 = 0 ;
38828 int res1 = 0 ;
38829 bool temp2 = false ;
38830 PyObject * obj0 = 0 ;
38831 PyObject * obj1 = 0 ;
38832 char * kwnames[] = {
38833 (char *) "self",(char *) "translators", NULL
38834 };
38835
38836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_SetTranslators",kwnames,&obj0,&obj1)) SWIG_fail;
38837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38838 if (!SWIG_IsOK(res1)) {
38839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_SetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38840 }
38841 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38842 {
38843 if (! PySequence_Check(obj1)) {
38844 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38845 SWIG_fail;
38846 }
38847 arg2 = new wxArrayString;
38848 temp2 = true;
38849 int i, len=PySequence_Length(obj1);
38850 for (i=0; i<len; i++) {
38851 PyObject* item = PySequence_GetItem(obj1, i);
38852 wxString* s = wxString_in_helper(item);
38853 if (PyErr_Occurred()) SWIG_fail;
38854 arg2->Add(*s);
38855 delete s;
38856 Py_DECREF(item);
38857 }
38858 }
38859 {
38860 PyThreadState* __tstate = wxPyBeginAllowThreads();
38861 (arg1)->SetTranslators((wxArrayString const &)*arg2);
38862 wxPyEndAllowThreads(__tstate);
38863 if (PyErr_Occurred()) SWIG_fail;
38864 }
38865 resultobj = SWIG_Py_Void();
38866 {
38867 if (temp2) delete arg2;
38868 }
38869 return resultobj;
38870 fail:
38871 {
38872 if (temp2) delete arg2;
38873 }
38874 return NULL;
38875 }
38876
38877
38878 SWIGINTERN PyObject *_wrap_AboutDialogInfo_AddTranslator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38879 PyObject *resultobj = 0;
38880 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38881 wxString *arg2 = 0 ;
38882 void *argp1 = 0 ;
38883 int res1 = 0 ;
38884 bool temp2 = false ;
38885 PyObject * obj0 = 0 ;
38886 PyObject * obj1 = 0 ;
38887 char * kwnames[] = {
38888 (char *) "self",(char *) "translator", NULL
38889 };
38890
38891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AboutDialogInfo_AddTranslator",kwnames,&obj0,&obj1)) SWIG_fail;
38892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38893 if (!SWIG_IsOK(res1)) {
38894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_AddTranslator" "', expected argument " "1"" of type '" "wxAboutDialogInfo *""'");
38895 }
38896 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38897 {
38898 arg2 = wxString_in_helper(obj1);
38899 if (arg2 == NULL) SWIG_fail;
38900 temp2 = true;
38901 }
38902 {
38903 PyThreadState* __tstate = wxPyBeginAllowThreads();
38904 (arg1)->AddTranslator((wxString const &)*arg2);
38905 wxPyEndAllowThreads(__tstate);
38906 if (PyErr_Occurred()) SWIG_fail;
38907 }
38908 resultobj = SWIG_Py_Void();
38909 {
38910 if (temp2)
38911 delete arg2;
38912 }
38913 return resultobj;
38914 fail:
38915 {
38916 if (temp2)
38917 delete arg2;
38918 }
38919 return NULL;
38920 }
38921
38922
38923 SWIGINTERN PyObject *_wrap_AboutDialogInfo_HasTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38924 PyObject *resultobj = 0;
38925 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38926 bool result;
38927 void *argp1 = 0 ;
38928 int res1 = 0 ;
38929 PyObject *swig_obj[1] ;
38930
38931 if (!args) SWIG_fail;
38932 swig_obj[0] = args;
38933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38934 if (!SWIG_IsOK(res1)) {
38935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_HasTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38936 }
38937 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38938 {
38939 PyThreadState* __tstate = wxPyBeginAllowThreads();
38940 result = (bool)((wxAboutDialogInfo const *)arg1)->HasTranslators();
38941 wxPyEndAllowThreads(__tstate);
38942 if (PyErr_Occurred()) SWIG_fail;
38943 }
38944 {
38945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38946 }
38947 return resultobj;
38948 fail:
38949 return NULL;
38950 }
38951
38952
38953 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetTranslators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38954 PyObject *resultobj = 0;
38955 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38956 wxArrayString *result = 0 ;
38957 void *argp1 = 0 ;
38958 int res1 = 0 ;
38959 PyObject *swig_obj[1] ;
38960
38961 if (!args) SWIG_fail;
38962 swig_obj[0] = args;
38963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38964 if (!SWIG_IsOK(res1)) {
38965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetTranslators" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38966 }
38967 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
38968 {
38969 PyThreadState* __tstate = wxPyBeginAllowThreads();
38970 {
38971 wxArrayString const &_result_ref = ((wxAboutDialogInfo const *)arg1)->GetTranslators();
38972 result = (wxArrayString *) &_result_ref;
38973 }
38974 wxPyEndAllowThreads(__tstate);
38975 if (PyErr_Occurred()) SWIG_fail;
38976 }
38977 {
38978 resultobj = wxArrayString2PyList_helper(*result);
38979 }
38980 return resultobj;
38981 fail:
38982 return NULL;
38983 }
38984
38985
38986 SWIGINTERN PyObject *_wrap_AboutDialogInfo_IsSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38987 PyObject *resultobj = 0;
38988 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
38989 bool result;
38990 void *argp1 = 0 ;
38991 int res1 = 0 ;
38992 PyObject *swig_obj[1] ;
38993
38994 if (!args) SWIG_fail;
38995 swig_obj[0] = args;
38996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
38997 if (!SWIG_IsOK(res1)) {
38998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_IsSimple" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
38999 }
39000 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39001 {
39002 PyThreadState* __tstate = wxPyBeginAllowThreads();
39003 result = (bool)((wxAboutDialogInfo const *)arg1)->IsSimple();
39004 wxPyEndAllowThreads(__tstate);
39005 if (PyErr_Occurred()) SWIG_fail;
39006 }
39007 {
39008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39009 }
39010 return resultobj;
39011 fail:
39012 return NULL;
39013 }
39014
39015
39016 SWIGINTERN PyObject *_wrap_AboutDialogInfo_GetDescriptionAndCredits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39017 PyObject *resultobj = 0;
39018 wxAboutDialogInfo *arg1 = (wxAboutDialogInfo *) 0 ;
39019 wxString result;
39020 void *argp1 = 0 ;
39021 int res1 = 0 ;
39022 PyObject *swig_obj[1] ;
39023
39024 if (!args) SWIG_fail;
39025 swig_obj[0] = args;
39026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAboutDialogInfo, 0 | 0 );
39027 if (!SWIG_IsOK(res1)) {
39028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutDialogInfo_GetDescriptionAndCredits" "', expected argument " "1"" of type '" "wxAboutDialogInfo const *""'");
39029 }
39030 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39031 {
39032 PyThreadState* __tstate = wxPyBeginAllowThreads();
39033 result = ((wxAboutDialogInfo const *)arg1)->GetDescriptionAndCredits();
39034 wxPyEndAllowThreads(__tstate);
39035 if (PyErr_Occurred()) SWIG_fail;
39036 }
39037 {
39038 #if wxUSE_UNICODE
39039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39040 #else
39041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39042 #endif
39043 }
39044 return resultobj;
39045 fail:
39046 return NULL;
39047 }
39048
39049
39050 SWIGINTERN PyObject *AboutDialogInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39051 PyObject *obj;
39052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39053 SWIG_TypeNewClientData(SWIGTYPE_p_wxAboutDialogInfo, SWIG_NewClientData(obj));
39054 return SWIG_Py_Void();
39055 }
39056
39057 SWIGINTERN PyObject *AboutDialogInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39058 return SWIG_Python_InitShadowInstance(args);
39059 }
39060
39061 SWIGINTERN PyObject *_wrap_AboutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39062 PyObject *resultobj = 0;
39063 wxAboutDialogInfo *arg1 = 0 ;
39064 void *argp1 = 0 ;
39065 int res1 = 0 ;
39066 PyObject * obj0 = 0 ;
39067 char * kwnames[] = {
39068 (char *) "info", NULL
39069 };
39070
39071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AboutBox",kwnames,&obj0)) SWIG_fail;
39072 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxAboutDialogInfo, 0 | 0);
39073 if (!SWIG_IsOK(res1)) {
39074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39075 }
39076 if (!argp1) {
39077 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AboutBox" "', expected argument " "1"" of type '" "wxAboutDialogInfo const &""'");
39078 }
39079 arg1 = reinterpret_cast< wxAboutDialogInfo * >(argp1);
39080 {
39081 PyThreadState* __tstate = wxPyBeginAllowThreads();
39082 wxAboutBox((wxAboutDialogInfo const &)*arg1);
39083 wxPyEndAllowThreads(__tstate);
39084 if (PyErr_Occurred()) SWIG_fail;
39085 }
39086 resultobj = SWIG_Py_Void();
39087 return resultobj;
39088 fail:
39089 return NULL;
39090 }
39091
39092
39093 static PyMethodDef SwigMethods[] = {
39094 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
39095 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
39096 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
39097 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
39098 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
39099 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
39100 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
39101 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
39102 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39103 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39104 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
39105 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
39106 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
39107 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
39108 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
39109 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
39110 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
39111 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
39112 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
39113 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
39114 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39115 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
39116 { (char *)"GetStockHelpString", (PyCFunction) _wrap_GetStockHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
39117 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
39118 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
39119 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
39120 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
39121 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
39122 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
39123 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
39124 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
39125 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
39126 { (char *)"IsPlatformLittleEndian", (PyCFunction)_wrap_IsPlatformLittleEndian, METH_NOARGS, NULL},
39127 { (char *)"IsPlatform64Bit", (PyCFunction)_wrap_IsPlatform64Bit, METH_NOARGS, NULL},
39128 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
39129 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
39130 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
39131 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39132 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
39133 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
39134 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
39135 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
39136 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
39137 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
39138 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
39139 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
39140 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
39141 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
39142 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
39143 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
39144 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39145 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39146 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39147 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
39148 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39149 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39150 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
39151 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
39152 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
39153 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
39154 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
39155 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
39156 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
39157 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
39158 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
39159 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
39160 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
39161 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
39162 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
39163 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39164 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
39165 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39166 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
39167 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
39168 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
39169 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39170 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
39171 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
39172 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
39173 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
39174 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
39175 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
39176 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
39177 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
39178 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
39179 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
39180 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
39181 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
39182 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
39183 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
39184 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
39185 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
39186 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
39187 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
39188 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39189 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
39190 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
39191 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
39192 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
39193 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
39194 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
39195 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
39196 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
39197 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
39198 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
39199 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
39200 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
39201 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
39202 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
39203 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
39204 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
39205 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
39206 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
39207 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
39208 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
39209 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
39210 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
39211 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
39212 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
39213 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
39214 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
39215 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
39216 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
39217 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
39218 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
39219 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
39220 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
39221 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
39222 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
39223 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
39224 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
39225 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
39226 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
39227 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
39228 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
39229 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39230 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
39231 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
39232 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
39233 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
39234 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
39235 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39236 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
39237 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
39238 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
39239 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
39240 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
39241 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
39242 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
39243 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39244 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
39245 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
39246 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
39247 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
39248 { (char *)"delete_StopWatch", (PyCFunction)_wrap_delete_StopWatch, METH_O, NULL},
39249 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39250 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
39251 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
39252 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
39253 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
39254 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
39255 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39256 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
39257 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39258 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
39259 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
39260 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39261 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39262 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
39263 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
39264 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
39265 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
39266 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
39267 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
39268 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
39269 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
39270 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
39271 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
39272 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
39273 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39274 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
39275 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
39276 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
39277 { (char *)"new_PlatformInformation", (PyCFunction)_wrap_new_PlatformInformation, METH_NOARGS, NULL},
39278 { (char *)"PlatformInformation___eq__", (PyCFunction) _wrap_PlatformInformation___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39279 { (char *)"PlatformInformation___ne__", (PyCFunction) _wrap_PlatformInformation___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39280 { (char *)"PlatformInformation_GetOSMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMajorVersion, METH_O, NULL},
39281 { (char *)"PlatformInformation_GetOSMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetOSMinorVersion, METH_O, NULL},
39282 { (char *)"PlatformInformation_CheckOSVersion", (PyCFunction) _wrap_PlatformInformation_CheckOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39283 { (char *)"PlatformInformation_GetToolkitMajorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMajorVersion, METH_O, NULL},
39284 { (char *)"PlatformInformation_GetToolkitMinorVersion", (PyCFunction)_wrap_PlatformInformation_GetToolkitMinorVersion, METH_O, NULL},
39285 { (char *)"PlatformInformation_CheckToolkitVersion", (PyCFunction) _wrap_PlatformInformation_CheckToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39286 { (char *)"PlatformInformation_IsUsingUniversalWidgets", (PyCFunction)_wrap_PlatformInformation_IsUsingUniversalWidgets, METH_O, NULL},
39287 { (char *)"PlatformInformation_GetOperatingSystemId", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemId, METH_O, NULL},
39288 { (char *)"PlatformInformation_GetPortId", (PyCFunction)_wrap_PlatformInformation_GetPortId, METH_O, NULL},
39289 { (char *)"PlatformInformation_GetArchitecture", (PyCFunction)_wrap_PlatformInformation_GetArchitecture, METH_O, NULL},
39290 { (char *)"PlatformInformation_GetEndianness", (PyCFunction)_wrap_PlatformInformation_GetEndianness, METH_O, NULL},
39291 { (char *)"PlatformInformation_GetOperatingSystemFamilyName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemFamilyName, METH_O, NULL},
39292 { (char *)"PlatformInformation_GetOperatingSystemIdName", (PyCFunction)_wrap_PlatformInformation_GetOperatingSystemIdName, METH_O, NULL},
39293 { (char *)"PlatformInformation_GetPortIdName", (PyCFunction)_wrap_PlatformInformation_GetPortIdName, METH_O, NULL},
39294 { (char *)"PlatformInformation_GetPortIdShortName", (PyCFunction)_wrap_PlatformInformation_GetPortIdShortName, METH_O, NULL},
39295 { (char *)"PlatformInformation_GetArchName", (PyCFunction)_wrap_PlatformInformation_GetArchName, METH_O, NULL},
39296 { (char *)"PlatformInformation_GetEndiannessName", (PyCFunction)_wrap_PlatformInformation_GetEndiannessName, METH_O, NULL},
39297 { (char *)"PlatformInformation_SetOSVersion", (PyCFunction) _wrap_PlatformInformation_SetOSVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39298 { (char *)"PlatformInformation_SetToolkitVersion", (PyCFunction) _wrap_PlatformInformation_SetToolkitVersion, METH_VARARGS | METH_KEYWORDS, NULL},
39299 { (char *)"PlatformInformation_SetOperatingSystemId", (PyCFunction) _wrap_PlatformInformation_SetOperatingSystemId, METH_VARARGS | METH_KEYWORDS, NULL},
39300 { (char *)"PlatformInformation_SetPortId", (PyCFunction) _wrap_PlatformInformation_SetPortId, METH_VARARGS | METH_KEYWORDS, NULL},
39301 { (char *)"PlatformInformation_SetArchitecture", (PyCFunction) _wrap_PlatformInformation_SetArchitecture, METH_VARARGS | METH_KEYWORDS, NULL},
39302 { (char *)"PlatformInformation_SetEndianness", (PyCFunction) _wrap_PlatformInformation_SetEndianness, METH_VARARGS | METH_KEYWORDS, NULL},
39303 { (char *)"PlatformInformation_IsOk", (PyCFunction)_wrap_PlatformInformation_IsOk, METH_O, NULL},
39304 { (char *)"PlatformInformation_swigregister", PlatformInformation_swigregister, METH_VARARGS, NULL},
39305 { (char *)"PlatformInformation_swiginit", PlatformInformation_swiginit, METH_VARARGS, NULL},
39306 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
39307 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
39308 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
39309 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
39310 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
39311 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
39312 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39313 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39314 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
39315 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
39316 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
39317 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
39318 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
39319 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
39320 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39321 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
39322 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
39323 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39324 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
39325 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
39326 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
39327 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
39328 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
39329 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
39330 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
39331 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
39332 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39333 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
39334 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
39335 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
39336 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
39337 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
39338 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
39339 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
39340 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
39341 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
39342 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
39343 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
39344 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
39345 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
39346 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
39347 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
39348 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
39349 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39350 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
39351 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
39352 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39353 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
39354 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
39355 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
39356 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
39357 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39358 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39359 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39360 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
39361 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
39362 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
39363 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
39364 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
39365 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
39366 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
39367 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
39368 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
39369 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
39370 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
39371 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
39372 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
39373 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
39374 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
39375 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
39376 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
39377 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
39378 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
39379 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
39380 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
39381 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
39382 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
39383 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
39384 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
39385 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
39386 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39387 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
39388 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
39389 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
39390 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
39391 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
39392 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
39393 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
39394 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
39395 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
39396 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
39397 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
39398 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
39399 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
39400 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
39401 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
39402 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
39403 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
39404 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
39405 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39406 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39407 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
39408 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
39409 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
39410 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
39411 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
39412 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
39413 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
39414 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
39415 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
39416 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
39417 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
39418 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
39419 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
39420 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39421 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
39422 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
39423 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39424 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39425 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
39426 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
39427 { (char *)"delete_Process", (PyCFunction)_wrap_delete_Process, METH_O, NULL},
39428 { (char *)"Process_GetPid", (PyCFunction)_wrap_Process_GetPid, METH_O, NULL},
39429 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39430 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
39431 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
39432 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
39433 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
39434 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
39435 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
39436 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
39437 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
39438 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
39439 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
39440 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
39441 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
39442 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
39443 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39444 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
39445 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
39446 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
39447 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
39448 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
39449 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
39450 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
39451 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
39452 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
39453 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
39454 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
39455 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
39456 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
39457 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
39458 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
39459 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
39460 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
39461 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
39462 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
39463 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
39464 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
39465 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
39466 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
39467 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
39468 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
39469 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
39470 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
39471 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
39472 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
39473 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
39474 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
39475 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
39476 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
39477 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
39478 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
39479 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
39480 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
39481 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
39482 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
39483 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
39484 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
39485 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
39486 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
39487 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
39488 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
39489 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
39490 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
39491 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
39492 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
39493 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
39494 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
39495 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
39496 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
39497 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
39498 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
39499 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
39500 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
39501 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
39502 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
39503 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
39504 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
39505 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
39506 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
39507 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
39508 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
39509 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39510 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
39511 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
39512 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
39513 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
39514 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
39515 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
39516 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
39517 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
39518 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
39519 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
39520 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39521 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
39522 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
39523 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
39524 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
39525 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
39526 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
39527 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
39528 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
39529 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
39530 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39531 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
39532 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
39533 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
39534 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39535 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
39536 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
39537 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
39538 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
39539 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
39540 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
39541 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
39542 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
39543 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
39544 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
39545 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
39546 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
39547 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
39548 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
39549 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
39550 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
39551 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
39552 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
39553 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
39554 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
39555 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39556 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39557 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
39558 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39559 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39560 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
39561 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
39562 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
39563 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
39564 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
39565 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
39566 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
39567 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
39568 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
39569 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
39570 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
39571 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
39572 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
39573 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
39574 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
39575 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
39576 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
39577 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
39578 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
39579 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
39580 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
39581 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39582 { (char *)"ArtProvider_Push", (PyCFunction) _wrap_ArtProvider_Push, METH_VARARGS | METH_KEYWORDS, NULL},
39583 { (char *)"ArtProvider_Insert", (PyCFunction) _wrap_ArtProvider_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
39584 { (char *)"ArtProvider_Pop", (PyCFunction)_wrap_ArtProvider_Pop, METH_NOARGS, NULL},
39585 { (char *)"ArtProvider_Delete", (PyCFunction) _wrap_ArtProvider_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
39586 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39587 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
39588 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
39589 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
39590 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
39591 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
39592 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
39593 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39594 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
39595 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
39596 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
39597 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
39598 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
39599 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
39600 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39601 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
39602 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39603 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
39604 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
39605 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39606 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39607 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
39608 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
39609 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
39610 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
39611 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39612 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
39613 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
39614 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
39615 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
39616 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
39617 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
39618 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39619 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39620 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
39621 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
39622 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
39623 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39624 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
39625 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
39626 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
39627 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39628 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
39629 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
39630 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
39631 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
39632 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
39633 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
39634 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
39635 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
39636 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
39637 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
39638 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
39639 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
39640 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
39641 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
39642 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
39643 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
39644 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
39645 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
39646 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
39647 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
39648 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
39649 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39650 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
39651 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
39652 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
39653 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
39654 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39655 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
39656 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
39657 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
39658 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39659 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
39660 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
39661 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
39662 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
39663 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
39664 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
39665 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
39666 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
39667 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
39668 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
39669 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39670 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39671 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39672 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
39673 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39674 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
39675 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
39676 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
39677 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
39678 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
39679 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
39680 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
39681 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39682 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39683 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39684 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39685 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39686 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39687 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39688 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39689 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39690 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39691 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39692 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39693 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39694 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39695 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39696 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39697 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39698 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
39699 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39700 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39701 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
39702 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39703 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
39704 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
39705 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
39706 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
39707 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
39708 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
39709 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39710 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39711 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39712 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
39713 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39714 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39715 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39716 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
39717 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39718 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
39719 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
39720 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
39721 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
39722 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
39723 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39724 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
39725 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
39726 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
39727 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
39728 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
39729 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
39730 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39731 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
39732 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
39733 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
39734 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39735 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
39736 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39737 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39738 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
39739 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
39740 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
39741 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
39742 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
39743 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
39744 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
39745 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
39746 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39747 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
39748 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
39749 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
39750 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
39751 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39752 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39753 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39754 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39755 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39756 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39757 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
39758 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39759 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
39760 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
39761 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
39762 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39763 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
39764 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
39765 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
39766 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
39767 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
39768 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
39769 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
39770 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
39771 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
39772 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
39773 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
39774 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
39775 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
39776 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
39777 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39778 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
39779 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39780 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
39781 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39782 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
39783 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39784 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39785 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39786 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
39787 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
39788 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39789 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39790 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39791 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
39792 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39793 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39794 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39795 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39796 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
39797 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
39798 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
39799 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
39800 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39801 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39802 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
39803 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
39804 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
39805 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
39806 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
39807 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
39808 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
39809 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
39810 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
39811 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
39812 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
39813 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
39814 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
39815 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
39816 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
39817 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
39818 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
39819 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
39820 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
39821 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
39822 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
39823 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
39824 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
39825 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
39826 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
39827 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
39828 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
39829 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
39830 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
39831 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
39832 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
39833 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
39834 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
39835 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
39836 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39837 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
39838 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
39839 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
39840 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
39841 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
39842 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
39843 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
39844 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
39845 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
39846 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
39847 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
39848 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
39849 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
39850 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
39851 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
39852 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
39853 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
39854 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
39855 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
39856 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39857 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39858 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
39859 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
39860 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
39861 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
39862 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
39863 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
39864 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
39865 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
39866 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
39867 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
39868 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39869 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
39870 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39871 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
39872 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
39873 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
39874 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39875 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
39876 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39877 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
39878 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
39879 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
39880 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
39881 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39882 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
39883 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
39884 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
39885 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39886 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
39887 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
39888 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
39889 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
39890 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
39891 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
39892 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
39893 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39894 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
39895 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
39896 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
39897 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
39898 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
39899 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39900 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39901 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
39902 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
39903 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39904 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
39905 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
39906 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
39907 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
39908 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39909 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39910 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
39911 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
39912 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
39913 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
39914 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
39915 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
39916 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
39917 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
39918 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39919 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
39920 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
39921 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
39922 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
39923 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39924 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
39925 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
39926 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
39927 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
39928 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
39929 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
39930 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
39931 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
39932 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
39933 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39934 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
39935 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39936 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
39937 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
39938 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39939 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
39940 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
39941 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
39942 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
39943 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39944 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
39945 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
39946 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
39947 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39948 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39949 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
39950 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39951 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
39952 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
39953 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
39954 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
39955 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
39956 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
39957 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39958 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
39959 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39960 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39961 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
39962 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39963 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39964 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
39965 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
39966 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
39967 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
39968 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
39969 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
39970 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
39971 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
39972 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
39973 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
39974 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
39975 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
39976 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
39977 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
39978 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
39979 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
39980 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
39981 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
39982 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
39983 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
39984 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
39985 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
39986 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
39987 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
39988 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
39989 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
39990 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
39991 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
39992 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
39993 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
39994 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
39995 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
39996 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
39997 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
39998 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
39999 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
40000 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
40001 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
40002 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
40003 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
40004 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
40005 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
40006 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
40007 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
40008 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
40009 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
40010 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
40011 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
40012 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
40013 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
40014 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
40015 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
40016 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
40017 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
40018 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
40019 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
40020 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
40021 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
40022 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
40023 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
40024 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
40025 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
40026 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
40027 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
40028 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
40029 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
40030 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
40031 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
40032 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
40033 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
40034 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
40035 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
40036 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
40037 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
40038 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
40039 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
40040 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
40041 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
40042 { (char *)"StandardPaths_GetTempDir", (PyCFunction)_wrap_StandardPaths_GetTempDir, METH_O, NULL},
40043 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
40044 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
40045 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
40046 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
40047 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
40048 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
40049 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
40050 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
40051 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
40052 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
40053 { (char *)"new_AboutDialogInfo", (PyCFunction)_wrap_new_AboutDialogInfo, METH_NOARGS, NULL},
40054 { (char *)"delete_AboutDialogInfo", (PyCFunction)_wrap_delete_AboutDialogInfo, METH_O, NULL},
40055 { (char *)"AboutDialogInfo_SetName", (PyCFunction) _wrap_AboutDialogInfo_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
40056 { (char *)"AboutDialogInfo_GetName", (PyCFunction)_wrap_AboutDialogInfo_GetName, METH_O, NULL},
40057 { (char *)"AboutDialogInfo_SetVersion", (PyCFunction) _wrap_AboutDialogInfo_SetVersion, METH_VARARGS | METH_KEYWORDS, NULL},
40058 { (char *)"AboutDialogInfo_HasVersion", (PyCFunction)_wrap_AboutDialogInfo_HasVersion, METH_O, NULL},
40059 { (char *)"AboutDialogInfo_GetVersion", (PyCFunction)_wrap_AboutDialogInfo_GetVersion, METH_O, NULL},
40060 { (char *)"AboutDialogInfo_SetDescription", (PyCFunction) _wrap_AboutDialogInfo_SetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
40061 { (char *)"AboutDialogInfo_HasDescription", (PyCFunction)_wrap_AboutDialogInfo_HasDescription, METH_O, NULL},
40062 { (char *)"AboutDialogInfo_GetDescription", (PyCFunction)_wrap_AboutDialogInfo_GetDescription, METH_O, NULL},
40063 { (char *)"AboutDialogInfo_SetCopyright", (PyCFunction) _wrap_AboutDialogInfo_SetCopyright, METH_VARARGS | METH_KEYWORDS, NULL},
40064 { (char *)"AboutDialogInfo_HasCopyright", (PyCFunction)_wrap_AboutDialogInfo_HasCopyright, METH_O, NULL},
40065 { (char *)"AboutDialogInfo_GetCopyright", (PyCFunction)_wrap_AboutDialogInfo_GetCopyright, METH_O, NULL},
40066 { (char *)"AboutDialogInfo_SetLicence", (PyCFunction) _wrap_AboutDialogInfo_SetLicence, METH_VARARGS | METH_KEYWORDS, NULL},
40067 { (char *)"AboutDialogInfo_SetLicense", (PyCFunction) _wrap_AboutDialogInfo_SetLicense, METH_VARARGS | METH_KEYWORDS, NULL},
40068 { (char *)"AboutDialogInfo_HasLicence", (PyCFunction)_wrap_AboutDialogInfo_HasLicence, METH_O, NULL},
40069 { (char *)"AboutDialogInfo_GetLicence", (PyCFunction)_wrap_AboutDialogInfo_GetLicence, METH_O, NULL},
40070 { (char *)"AboutDialogInfo_SetIcon", (PyCFunction) _wrap_AboutDialogInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
40071 { (char *)"AboutDialogInfo_HasIcon", (PyCFunction)_wrap_AboutDialogInfo_HasIcon, METH_O, NULL},
40072 { (char *)"AboutDialogInfo_GetIcon", (PyCFunction)_wrap_AboutDialogInfo_GetIcon, METH_O, NULL},
40073 { (char *)"AboutDialogInfo__SetWebSite", (PyCFunction) _wrap_AboutDialogInfo__SetWebSite, METH_VARARGS | METH_KEYWORDS, NULL},
40074 { (char *)"AboutDialogInfo__GetWebSiteURL", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteURL, METH_O, NULL},
40075 { (char *)"AboutDialogInfo__GetWebSiteDescription", (PyCFunction)_wrap_AboutDialogInfo__GetWebSiteDescription, METH_O, NULL},
40076 { (char *)"AboutDialogInfo_HasWebSite", (PyCFunction)_wrap_AboutDialogInfo_HasWebSite, METH_O, NULL},
40077 { (char *)"AboutDialogInfo_SetDevelopers", (PyCFunction) _wrap_AboutDialogInfo_SetDevelopers, METH_VARARGS | METH_KEYWORDS, NULL},
40078 { (char *)"AboutDialogInfo_AddDeveloper", (PyCFunction) _wrap_AboutDialogInfo_AddDeveloper, METH_VARARGS | METH_KEYWORDS, NULL},
40079 { (char *)"AboutDialogInfo_HasDevelopers", (PyCFunction)_wrap_AboutDialogInfo_HasDevelopers, METH_O, NULL},
40080 { (char *)"AboutDialogInfo_GetDevelopers", (PyCFunction)_wrap_AboutDialogInfo_GetDevelopers, METH_O, NULL},
40081 { (char *)"AboutDialogInfo_SetDocWriters", (PyCFunction) _wrap_AboutDialogInfo_SetDocWriters, METH_VARARGS | METH_KEYWORDS, NULL},
40082 { (char *)"AboutDialogInfo_AddDocWriter", (PyCFunction) _wrap_AboutDialogInfo_AddDocWriter, METH_VARARGS | METH_KEYWORDS, NULL},
40083 { (char *)"AboutDialogInfo_HasDocWriters", (PyCFunction)_wrap_AboutDialogInfo_HasDocWriters, METH_O, NULL},
40084 { (char *)"AboutDialogInfo_GetDocWriters", (PyCFunction)_wrap_AboutDialogInfo_GetDocWriters, METH_O, NULL},
40085 { (char *)"AboutDialogInfo_SetArtists", (PyCFunction) _wrap_AboutDialogInfo_SetArtists, METH_VARARGS | METH_KEYWORDS, NULL},
40086 { (char *)"AboutDialogInfo_AddArtist", (PyCFunction) _wrap_AboutDialogInfo_AddArtist, METH_VARARGS | METH_KEYWORDS, NULL},
40087 { (char *)"AboutDialogInfo_HasArtists", (PyCFunction)_wrap_AboutDialogInfo_HasArtists, METH_O, NULL},
40088 { (char *)"AboutDialogInfo_GetArtists", (PyCFunction)_wrap_AboutDialogInfo_GetArtists, METH_O, NULL},
40089 { (char *)"AboutDialogInfo_SetTranslators", (PyCFunction) _wrap_AboutDialogInfo_SetTranslators, METH_VARARGS | METH_KEYWORDS, NULL},
40090 { (char *)"AboutDialogInfo_AddTranslator", (PyCFunction) _wrap_AboutDialogInfo_AddTranslator, METH_VARARGS | METH_KEYWORDS, NULL},
40091 { (char *)"AboutDialogInfo_HasTranslators", (PyCFunction)_wrap_AboutDialogInfo_HasTranslators, METH_O, NULL},
40092 { (char *)"AboutDialogInfo_GetTranslators", (PyCFunction)_wrap_AboutDialogInfo_GetTranslators, METH_O, NULL},
40093 { (char *)"AboutDialogInfo_IsSimple", (PyCFunction)_wrap_AboutDialogInfo_IsSimple, METH_O, NULL},
40094 { (char *)"AboutDialogInfo_GetDescriptionAndCredits", (PyCFunction)_wrap_AboutDialogInfo_GetDescriptionAndCredits, METH_O, NULL},
40095 { (char *)"AboutDialogInfo_swigregister", AboutDialogInfo_swigregister, METH_VARARGS, NULL},
40096 { (char *)"AboutDialogInfo_swiginit", AboutDialogInfo_swiginit, METH_VARARGS, NULL},
40097 { (char *)"AboutBox", (PyCFunction) _wrap_AboutBox, METH_VARARGS | METH_KEYWORDS, NULL},
40098 { NULL, NULL, 0, NULL }
40099 };
40100
40101
40102 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
40103
40104 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
40105 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
40106 }
40107 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
40108 return (void *)((wxEvent *) ((wxMenuEvent *) x));
40109 }
40110 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
40111 return (void *)((wxEvent *) ((wxCloseEvent *) x));
40112 }
40113 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
40114 return (void *)((wxEvent *) ((wxMouseEvent *) x));
40115 }
40116 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
40117 return (void *)((wxEvent *) ((wxEraseEvent *) x));
40118 }
40119 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
40120 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
40121 }
40122 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
40123 return (void *)((wxEvent *) ((wxTimerEvent *) x));
40124 }
40125 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
40126 return (void *)((wxEvent *) ((wxPowerEvent *) x));
40127 }
40128 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
40129 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
40130 }
40131 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
40132 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
40133 }
40134 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
40135 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
40136 }
40137 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
40138 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
40139 }
40140 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
40141 return (void *)((wxEvent *) ((wxPyEvent *) x));
40142 }
40143 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
40144 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
40145 }
40146 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
40147 return (void *)((wxEvent *) ((wxIdleEvent *) x));
40148 }
40149 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
40150 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
40151 }
40152 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
40153 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
40154 }
40155 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
40156 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
40157 }
40158 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
40159 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
40160 }
40161 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
40162 return (void *)((wxEvent *) ((wxActivateEvent *) x));
40163 }
40164 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
40165 return (void *)((wxEvent *) ((wxSizeEvent *) x));
40166 }
40167 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
40168 return (void *)((wxEvent *) ((wxMoveEvent *) x));
40169 }
40170 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
40171 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
40172 }
40173 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
40174 return (void *)((wxEvent *) ((wxPaintEvent *) x));
40175 }
40176 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
40177 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
40178 }
40179 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
40180 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
40181 }
40182 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
40183 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
40184 }
40185 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
40186 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
40187 }
40188 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
40189 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
40190 }
40191 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
40192 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40193 }
40194 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
40195 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
40196 }
40197 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
40198 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
40199 }
40200 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
40201 return (void *)((wxEvent *) ((wxFocusEvent *) x));
40202 }
40203 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
40204 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
40205 }
40206 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
40207 return (void *)((wxEvent *) ((wxProcessEvent *) x));
40208 }
40209 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
40210 return (void *)((wxEvent *) ((wxShowEvent *) x));
40211 }
40212 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
40213 return (void *)((wxEvent *) ((wxCommandEvent *) x));
40214 }
40215 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
40216 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
40217 }
40218 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
40219 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40220 }
40221 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
40222 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
40223 }
40224 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
40225 return (void *)((wxEvent *) ((wxKeyEvent *) x));
40226 }
40227 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
40228 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
40229 }
40230 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
40231 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
40232 }
40233 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
40234 return (void *)((wxConfigBase *) ((wxConfig *) x));
40235 }
40236 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
40237 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40238 }
40239 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
40240 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
40241 }
40242 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
40243 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
40244 }
40245 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
40246 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40247 }
40248 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
40249 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
40250 }
40251 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
40252 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
40253 }
40254 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
40255 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
40256 }
40257 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
40258 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40259 }
40260 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
40261 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40262 }
40263 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
40264 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
40265 }
40266 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
40267 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
40268 }
40269 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
40270 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
40271 }
40272 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
40273 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40274 }
40275 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
40276 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
40277 }
40278 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40279 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
40280 }
40281 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
40282 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
40283 }
40284 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40285 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
40286 }
40287 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
40288 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
40289 }
40290 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
40291 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
40292 }
40293 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
40294 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
40295 }
40296 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
40297 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
40298 }
40299 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
40300 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
40301 }
40302 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
40303 return (void *)((wxEvtHandler *) ((wxWindow *) x));
40304 }
40305 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
40306 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40307 }
40308 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
40309 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
40310 }
40311 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
40312 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
40313 }
40314 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
40315 return (void *)((wxEvtHandler *) ((wxValidator *) x));
40316 }
40317 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
40318 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
40319 }
40320 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
40321 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
40322 }
40323 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
40324 return (void *)((wxEvtHandler *) ((wxMenu *) x));
40325 }
40326 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
40327 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
40328 }
40329 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
40330 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
40331 }
40332 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
40333 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
40334 }
40335 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
40336 return (void *)((wxObject *) ((wxSizerItem *) x));
40337 }
40338 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
40339 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
40340 }
40341 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
40342 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
40343 }
40344 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
40345 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
40346 }
40347 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
40348 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
40349 }
40350 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
40351 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
40352 }
40353 static void *_p_wxSizerTo_p_wxObject(void *x) {
40354 return (void *)((wxObject *) ((wxSizer *) x));
40355 }
40356 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
40357 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
40358 }
40359 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
40360 return (void *)((wxObject *) ((wxFileHistory *) x));
40361 }
40362 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
40363 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
40364 }
40365 static void *_p_wxEventTo_p_wxObject(void *x) {
40366 return (void *)((wxObject *) ((wxEvent *) x));
40367 }
40368 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
40369 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
40370 }
40371 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
40372 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
40373 }
40374 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
40375 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
40376 }
40377 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
40378 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
40379 }
40380 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
40381 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
40382 }
40383 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
40384 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
40385 }
40386 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
40387 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
40388 }
40389 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
40390 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
40391 }
40392 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
40393 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
40394 }
40395 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
40396 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
40397 }
40398 static void *_p_wxControlTo_p_wxObject(void *x) {
40399 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
40400 }
40401 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
40402 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
40403 }
40404 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
40405 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
40406 }
40407 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
40408 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
40409 }
40410 static void *_p_wxFSFileTo_p_wxObject(void *x) {
40411 return (void *)((wxObject *) ((wxFSFile *) x));
40412 }
40413 static void *_p_wxClipboardTo_p_wxObject(void *x) {
40414 return (void *)((wxObject *) ((wxClipboard *) x));
40415 }
40416 static void *_p_wxPySizerTo_p_wxObject(void *x) {
40417 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
40418 }
40419 static void *_p_wxPyEventTo_p_wxObject(void *x) {
40420 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
40421 }
40422 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
40423 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
40424 }
40425 static void *_p_wxShowEventTo_p_wxObject(void *x) {
40426 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
40427 }
40428 static void *_p_wxToolTipTo_p_wxObject(void *x) {
40429 return (void *)((wxObject *) ((wxToolTip *) x));
40430 }
40431 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
40432 return (void *)((wxObject *) ((wxMenuItem *) x));
40433 }
40434 static void *_p_wxDateEventTo_p_wxObject(void *x) {
40435 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
40436 }
40437 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
40438 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
40439 }
40440 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
40441 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
40442 }
40443 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
40444 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
40445 }
40446 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
40447 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
40448 }
40449 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
40450 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
40451 }
40452 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
40453 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
40454 }
40455 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
40456 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
40457 }
40458 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
40459 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
40460 }
40461 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
40462 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
40463 }
40464 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
40465 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
40466 }
40467 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
40468 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
40469 }
40470 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
40471 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
40472 }
40473 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
40474 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
40475 }
40476 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
40477 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
40478 }
40479 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
40480 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
40481 }
40482 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
40483 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
40484 }
40485 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
40486 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
40487 }
40488 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
40489 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
40490 }
40491 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
40492 return (void *)((wxObject *) ((wxImageHandler *) x));
40493 }
40494 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
40495 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
40496 }
40497 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
40498 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
40499 }
40500 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
40501 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
40502 }
40503 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
40504 return (void *)((wxObject *) ((wxEvtHandler *) x));
40505 }
40506 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
40507 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
40508 }
40509 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
40510 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
40511 }
40512 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
40513 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
40514 }
40515 static void *_p_wxImageTo_p_wxObject(void *x) {
40516 return (void *)((wxObject *) ((wxImage *) x));
40517 }
40518 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
40519 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
40520 }
40521 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
40522 return (void *)((wxObject *) ((wxSystemOptions *) x));
40523 }
40524 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
40525 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
40526 }
40527 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
40528 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
40529 }
40530 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
40531 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
40532 }
40533 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
40534 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
40535 }
40536 static void *_p_wxWindowTo_p_wxObject(void *x) {
40537 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
40538 }
40539 static void *_p_wxMenuTo_p_wxObject(void *x) {
40540 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
40541 }
40542 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
40543 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
40544 }
40545 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
40546 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
40547 }
40548 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
40549 return (void *)((wxObject *) ((wxFileSystem *) x));
40550 }
40551 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
40552 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
40553 }
40554 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
40555 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
40556 }
40557 static void *_p_wxPyAppTo_p_wxObject(void *x) {
40558 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
40559 }
40560 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
40561 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
40562 }
40563 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
40564 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
40565 }
40566 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
40567 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
40568 }
40569 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
40570 return (void *)((wxObject *) ((wxBusyInfo *) x));
40571 }
40572 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
40573 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
40574 }
40575 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
40576 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
40577 }
40578 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
40579 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
40580 }
40581 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
40582 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
40583 }
40584 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
40585 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
40586 }
40587 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
40588 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
40589 }
40590 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
40591 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
40592 }
40593 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
40594 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
40595 }
40596 static void *_p_wxValidatorTo_p_wxObject(void *x) {
40597 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
40598 }
40599 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
40600 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
40601 }
40602 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
40603 return (void *)((wxLog *) ((wxLogBuffer *) x));
40604 }
40605 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
40606 return (void *)((wxLog *) ((wxLogStderr *) x));
40607 }
40608 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
40609 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
40610 }
40611 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
40612 return (void *)((wxLog *) ((wxLogWindow *) x));
40613 }
40614 static void *_p_wxLogChainTo_p_wxLog(void *x) {
40615 return (void *)((wxLog *) ((wxLogChain *) x));
40616 }
40617 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
40618 return (void *)((wxLog *) ((wxLogGui *) x));
40619 }
40620 static void *_p_wxPyLogTo_p_wxLog(void *x) {
40621 return (void *)((wxLog *) ((wxPyLog *) x));
40622 }
40623 static void *_p_wxControlTo_p_wxWindow(void *x) {
40624 return (void *)((wxWindow *) ((wxControl *) x));
40625 }
40626 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
40627 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
40628 }
40629 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
40630 return (void *)((wxWindow *) ((wxMenuBar *) x));
40631 }
40632 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
40633 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
40634 }
40635 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
40636 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
40637 }
40638 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
40639 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, (void*)0, 0};
40640 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
40641 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
40642 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
40643 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
40644 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
40645 static swig_type_info _swigt__p_wxAboutDialogInfo = {"_p_wxAboutDialogInfo", "wxAboutDialogInfo *", 0, 0, (void*)0, 0};
40646 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
40647 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
40648 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
40649 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
40650 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
40651 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
40652 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
40653 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
40654 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
40655 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
40656 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
40657 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
40658 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
40659 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
40660 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
40661 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
40662 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
40663 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
40664 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
40665 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
40666 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
40667 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
40668 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
40669 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
40670 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
40671 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
40672 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
40673 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
40674 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
40675 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
40676 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
40677 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
40678 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
40679 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
40680 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
40681 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
40682 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
40683 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
40684 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
40685 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
40686 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
40687 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
40688 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
40689 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
40690 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
40691 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
40692 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
40693 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
40694 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
40695 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
40696 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
40697 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
40698 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
40699 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
40700 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
40701 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
40702 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
40703 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
40704 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
40705 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
40706 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
40707 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
40708 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
40709 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
40710 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
40711 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
40712 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
40713 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
40714 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
40715 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
40716 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
40717 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
40718 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
40719 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
40720 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
40721 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
40722 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
40723 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
40724 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
40725 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
40726 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
40727 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
40728 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
40729 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
40730 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
40731 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
40732 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
40733 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
40734 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
40735 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
40736 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
40737 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
40738 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
40739 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
40740 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
40741 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
40742 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
40743 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
40744 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
40745 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
40746 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
40747 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
40748 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
40749 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
40750 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
40751 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
40752 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
40753 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
40754 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
40755 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
40756 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
40757 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};
40758 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
40759 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
40760 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
40761 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
40762 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
40763 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
40764 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
40765 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
40766 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
40767 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
40768 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
40769 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
40770 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
40771 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
40772 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
40773 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
40774 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
40775 static swig_type_info _swigt__p_wxPlatformInfo = {"_p_wxPlatformInfo", "wxPlatformInfo *", 0, 0, (void*)0, 0};
40776 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
40777 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
40778 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
40779 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
40780 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
40781 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
40782 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
40783 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
40784 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
40785 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
40786 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
40787 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
40788 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
40789 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
40790 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
40791 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
40792 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
40793 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
40794 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
40795 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
40796 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
40797 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
40798 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
40799 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
40800 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
40801 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
40802 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
40803 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
40804 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
40805 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
40806 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
40807 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
40808 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
40809 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
40810 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
40811 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
40812
40813 static swig_type_info *swig_type_initial[] = {
40814 &_swigt__p_char,
40815 &_swigt__p_form_ops_t,
40816 &_swigt__p_int,
40817 &_swigt__p_unsigned_char,
40818 &_swigt__p_unsigned_int,
40819 &_swigt__p_unsigned_long,
40820 &_swigt__p_void,
40821 &_swigt__p_wxANIHandler,
40822 &_swigt__p_wxAboutDialogInfo,
40823 &_swigt__p_wxAcceleratorTable,
40824 &_swigt__p_wxActivateEvent,
40825 &_swigt__p_wxArrayString,
40826 &_swigt__p_wxBMPHandler,
40827 &_swigt__p_wxBitmap,
40828 &_swigt__p_wxBitmapDataObject,
40829 &_swigt__p_wxBoxSizer,
40830 &_swigt__p_wxBusyCursor,
40831 &_swigt__p_wxBusyInfo,
40832 &_swigt__p_wxCURHandler,
40833 &_swigt__p_wxCaret,
40834 &_swigt__p_wxChar,
40835 &_swigt__p_wxChildFocusEvent,
40836 &_swigt__p_wxClipboard,
40837 &_swigt__p_wxClipboardLocker,
40838 &_swigt__p_wxClipboardTextEvent,
40839 &_swigt__p_wxCloseEvent,
40840 &_swigt__p_wxColour,
40841 &_swigt__p_wxCommandEvent,
40842 &_swigt__p_wxConfig,
40843 &_swigt__p_wxConfigBase,
40844 &_swigt__p_wxConfigPathChanger,
40845 &_swigt__p_wxContextMenuEvent,
40846 &_swigt__p_wxControl,
40847 &_swigt__p_wxControlWithItems,
40848 &_swigt__p_wxCursor,
40849 &_swigt__p_wxCustomDataObject,
40850 &_swigt__p_wxDC,
40851 &_swigt__p_wxDataFormat,
40852 &_swigt__p_wxDataObject,
40853 &_swigt__p_wxDataObjectComposite,
40854 &_swigt__p_wxDataObjectSimple,
40855 &_swigt__p_wxDateEvent,
40856 &_swigt__p_wxDateSpan,
40857 &_swigt__p_wxDateTime,
40858 &_swigt__p_wxDateTime__TimeZone,
40859 &_swigt__p_wxDisplay,
40860 &_swigt__p_wxDisplayChangedEvent,
40861 &_swigt__p_wxDropFilesEvent,
40862 &_swigt__p_wxDuplexMode,
40863 &_swigt__p_wxEraseEvent,
40864 &_swigt__p_wxEvent,
40865 &_swigt__p_wxEvtHandler,
40866 &_swigt__p_wxFSFile,
40867 &_swigt__p_wxFileConfig,
40868 &_swigt__p_wxFileDataObject,
40869 &_swigt__p_wxFileHistory,
40870 &_swigt__p_wxFileSystem,
40871 &_swigt__p_wxFileType,
40872 &_swigt__p_wxFileTypeInfo,
40873 &_swigt__p_wxFlexGridSizer,
40874 &_swigt__p_wxFocusEvent,
40875 &_swigt__p_wxFont,
40876 &_swigt__p_wxFrame,
40877 &_swigt__p_wxGBSizerItem,
40878 &_swigt__p_wxGIFHandler,
40879 &_swigt__p_wxGridBagSizer,
40880 &_swigt__p_wxGridSizer,
40881 &_swigt__p_wxICOHandler,
40882 &_swigt__p_wxIcon,
40883 &_swigt__p_wxIconizeEvent,
40884 &_swigt__p_wxIdleEvent,
40885 &_swigt__p_wxImage,
40886 &_swigt__p_wxImageHandler,
40887 &_swigt__p_wxIndividualLayoutConstraint,
40888 &_swigt__p_wxInitDialogEvent,
40889 &_swigt__p_wxJPEGHandler,
40890 &_swigt__p_wxJoystick,
40891 &_swigt__p_wxJoystickEvent,
40892 &_swigt__p_wxKeyEvent,
40893 &_swigt__p_wxKillError,
40894 &_swigt__p_wxLayoutConstraints,
40895 &_swigt__p_wxLog,
40896 &_swigt__p_wxLogBuffer,
40897 &_swigt__p_wxLogChain,
40898 &_swigt__p_wxLogGui,
40899 &_swigt__p_wxLogNull,
40900 &_swigt__p_wxLogStderr,
40901 &_swigt__p_wxLogTextCtrl,
40902 &_swigt__p_wxLogWindow,
40903 &_swigt__p_wxMaximizeEvent,
40904 &_swigt__p_wxMenu,
40905 &_swigt__p_wxMenuBar,
40906 &_swigt__p_wxMenuEvent,
40907 &_swigt__p_wxMenuItem,
40908 &_swigt__p_wxMetafileDataObject,
40909 &_swigt__p_wxMimeTypesManager,
40910 &_swigt__p_wxMouseCaptureChangedEvent,
40911 &_swigt__p_wxMouseCaptureLostEvent,
40912 &_swigt__p_wxMouseEvent,
40913 &_swigt__p_wxMouseState,
40914 &_swigt__p_wxMoveEvent,
40915 &_swigt__p_wxMutexGuiLocker,
40916 &_swigt__p_wxNavigationKeyEvent,
40917 &_swigt__p_wxNcPaintEvent,
40918 &_swigt__p_wxNotifyEvent,
40919 &_swigt__p_wxObject,
40920 &_swigt__p_wxOutputStream,
40921 &_swigt__p_wxPCXHandler,
40922 &_swigt__p_wxPNGHandler,
40923 &_swigt__p_wxPNMHandler,
40924 &_swigt__p_wxPaintEvent,
40925 &_swigt__p_wxPaletteChangedEvent,
40926 &_swigt__p_wxPaperSize,
40927 &_swigt__p_wxPlatformInfo,
40928 &_swigt__p_wxPoint,
40929 &_swigt__p_wxPowerEvent,
40930 &_swigt__p_wxProcessEvent,
40931 &_swigt__p_wxPyApp,
40932 &_swigt__p_wxPyArtProvider,
40933 &_swigt__p_wxPyBitmapDataObject,
40934 &_swigt__p_wxPyCommandEvent,
40935 &_swigt__p_wxPyDataObjectSimple,
40936 &_swigt__p_wxPyDropSource,
40937 &_swigt__p_wxPyDropTarget,
40938 &_swigt__p_wxPyEvent,
40939 &_swigt__p_wxPyFileDropTarget,
40940 &_swigt__p_wxPyImageHandler,
40941 &_swigt__p_wxPyLog,
40942 &_swigt__p_wxPyProcess,
40943 &_swigt__p_wxPySizer,
40944 &_swigt__p_wxPyTextDataObject,
40945 &_swigt__p_wxPyTextDropTarget,
40946 &_swigt__p_wxPyTimer,
40947 &_swigt__p_wxPyTipProvider,
40948 &_swigt__p_wxPyValidator,
40949 &_swigt__p_wxQueryNewPaletteEvent,
40950 &_swigt__p_wxRect,
40951 &_swigt__p_wxScrollEvent,
40952 &_swigt__p_wxScrollWinEvent,
40953 &_swigt__p_wxSetCursorEvent,
40954 &_swigt__p_wxShowEvent,
40955 &_swigt__p_wxSingleInstanceChecker,
40956 &_swigt__p_wxSize,
40957 &_swigt__p_wxSizeEvent,
40958 &_swigt__p_wxSizer,
40959 &_swigt__p_wxSizerItem,
40960 &_swigt__p_wxSound,
40961 &_swigt__p_wxStandardPaths,
40962 &_swigt__p_wxStaticBoxSizer,
40963 &_swigt__p_wxStdDialogButtonSizer,
40964 &_swigt__p_wxStopWatch,
40965 &_swigt__p_wxString,
40966 &_swigt__p_wxSysColourChangedEvent,
40967 &_swigt__p_wxSystemOptions,
40968 &_swigt__p_wxSystemSettings,
40969 &_swigt__p_wxTGAHandler,
40970 &_swigt__p_wxTIFFHandler,
40971 &_swigt__p_wxTextCtrl,
40972 &_swigt__p_wxTextDataObject,
40973 &_swigt__p_wxTimeSpan,
40974 &_swigt__p_wxTimer,
40975 &_swigt__p_wxTimerEvent,
40976 &_swigt__p_wxTimerRunner,
40977 &_swigt__p_wxTipProvider,
40978 &_swigt__p_wxToolTip,
40979 &_swigt__p_wxURLDataObject,
40980 &_swigt__p_wxUpdateUIEvent,
40981 &_swigt__p_wxValidator,
40982 &_swigt__p_wxVideoMode,
40983 &_swigt__p_wxWindow,
40984 &_swigt__p_wxWindowCreateEvent,
40985 &_swigt__p_wxWindowDestroyEvent,
40986 &_swigt__p_wxWindowDisabler,
40987 &_swigt__p_wxXPMHandler,
40988 };
40989
40990 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
40991 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
40992 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
40993 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
40994 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
40995 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
40996 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
40997 static swig_cast_info _swigc__p_wxAboutDialogInfo[] = { {&_swigt__p_wxAboutDialogInfo, 0, 0, 0},{0, 0, 0, 0}};
40998 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
40999 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
41000 static swig_cast_info _swigc__p_wxBitmapDataObject[] = { {&_swigt__p_wxBitmapDataObject, 0, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject, 0, 0},{0, 0, 0, 0}};
41001 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
41002 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
41003 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
41004 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
41005 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
41006 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
41007 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
41008 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
41009 static swig_cast_info _swigc__p_wxConfigBase[] = { {&_swigt__p_wxFileConfig, _p_wxFileConfigTo_p_wxConfigBase, 0, 0}, {&_swigt__p_wxConfigBase, 0, 0, 0}, {&_swigt__p_wxConfig, _p_wxConfigTo_p_wxConfigBase, 0, 0},{0, 0, 0, 0}};
41010 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
41011 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
41012 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
41013 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
41014 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
41015 static swig_cast_info _swigc__p_wxDataObject[] = { {&_swigt__p_wxDataObjectSimple, _p_wxDataObjectSimpleTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyDataObjectSimple, _p_wxPyDataObjectSimpleTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxDataObjectComposite, _p_wxDataObjectCompositeTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxDataObject, 0, 0, 0}, {&_swigt__p_wxTextDataObject, _p_wxTextDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxBitmapDataObject, _p_wxBitmapDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxFileDataObject, _p_wxFileDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxCustomDataObject, _p_wxCustomDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxMetafileDataObject, _p_wxMetafileDataObjectTo_p_wxDataObject, 0, 0}, {&_swigt__p_wxURLDataObject, _p_wxURLDataObjectTo_p_wxDataObject, 0, 0},{0, 0, 0, 0}};
41016 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
41017 static swig_cast_info _swigc__p_wxDataObjectSimple[] = { {&_swigt__p_wxDataObjectSimple, 0, 0, 0}, {&_swigt__p_wxPyDataObjectSimple, _p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxTextDataObject, _p_wxTextDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxBitmapDataObject, _p_wxBitmapDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxPyBitmapDataObject, _p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxFileDataObject, _p_wxFileDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxCustomDataObject, _p_wxCustomDataObjectTo_p_wxDataObjectSimple, 0, 0}, {&_swigt__p_wxMetafileDataObject, _p_wxMetafileDataObjectTo_p_wxDataObjectSimple, 0, 0},{0, 0, 0, 0}};
41018 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
41019 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
41020 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
41021 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
41022 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
41023 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41024 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
41025 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
41026 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
41027 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
41028 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
41029 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
41030 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
41031 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
41032 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
41033 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
41034 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
41035 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
41036 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
41037 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41038 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41039 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
41040 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
41041 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
41042 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
41043 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41044 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
41045 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
41046 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
41047 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41048 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41049 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41050 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
41051 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
41052 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41053 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
41054 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
41055 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41056 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
41057 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
41058 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41059 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
41060 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
41061 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
41062 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
41063 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
41064 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
41065 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
41066 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
41067 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
41068 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
41069 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
41070 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41071 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
41072 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
41073 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
41074 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
41075 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
41076 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
41077 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
41078 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
41079 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
41080 static swig_cast_info _swigc__p_wxLog[] = { {&_swigt__p_wxLogBuffer, _p_wxLogBufferTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogStderr, _p_wxLogStderrTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogTextCtrl, _p_wxLogTextCtrlTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogWindow, _p_wxLogWindowTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogChain, _p_wxLogChainTo_p_wxLog, 0, 0}, {&_swigt__p_wxLogGui, _p_wxLogGuiTo_p_wxLog, 0, 0}, {&_swigt__p_wxPyLog, _p_wxPyLogTo_p_wxLog, 0, 0}, {&_swigt__p_wxLog, 0, 0, 0},{0, 0, 0, 0}};
41081 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
41082 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
41083 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
41084 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
41085 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
41086 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41087 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
41088 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
41089 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
41090 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
41091 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
41092 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
41093 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
41094 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41095 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
41096 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
41097 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41098 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
41099 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
41100 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
41101 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41102 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
41103 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
41104 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
41105 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
41106 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
41107 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
41108 static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
41109 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41110 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
41111 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
41112 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
41113 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
41114 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
41115 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
41116 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
41117 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
41118 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
41119 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
41120 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
41121 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
41122 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
41123 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
41124 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
41125 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
41126 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
41127 static swig_cast_info _swigc__p_wxPlatformInfo[] = { {&_swigt__p_wxPlatformInfo, 0, 0, 0},{0, 0, 0, 0}};
41128 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
41129 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
41130 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
41131 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
41132 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
41133 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
41134 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
41135 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0}, {&_swigt__p_wxPyTextDropTarget, _p_wxPyTextDropTargetTo_p_wxPyDropTarget, 0, 0}, {&_swigt__p_wxPyFileDropTarget, _p_wxPyFileDropTargetTo_p_wxPyDropTarget, 0, 0},{0, 0, 0, 0}};
41136 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41137 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
41138 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
41139 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
41140 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
41141 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
41142 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
41143 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
41144 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
41145 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
41146 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
41147 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
41148 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
41149 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
41150 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
41151 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
41152 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
41153 static swig_cast_info _swigc__p_wxTextDataObject[] = { {&_swigt__p_wxTextDataObject, 0, 0, 0}, {&_swigt__p_wxPyTextDataObject, _p_wxPyTextDataObjectTo_p_wxTextDataObject, 0, 0},{0, 0, 0, 0}};
41154 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
41155 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
41156 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
41157 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
41158 static swig_cast_info _swigc__p_wxTipProvider[] = { {&_swigt__p_wxTipProvider, 0, 0, 0}, {&_swigt__p_wxPyTipProvider, _p_wxPyTipProviderTo_p_wxTipProvider, 0, 0},{0, 0, 0, 0}};
41159 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
41160 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
41161 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
41162 static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};
41163 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
41164
41165 static swig_cast_info *swig_cast_initial[] = {
41166 _swigc__p_char,
41167 _swigc__p_form_ops_t,
41168 _swigc__p_int,
41169 _swigc__p_unsigned_char,
41170 _swigc__p_unsigned_int,
41171 _swigc__p_unsigned_long,
41172 _swigc__p_void,
41173 _swigc__p_wxANIHandler,
41174 _swigc__p_wxAboutDialogInfo,
41175 _swigc__p_wxAcceleratorTable,
41176 _swigc__p_wxActivateEvent,
41177 _swigc__p_wxArrayString,
41178 _swigc__p_wxBMPHandler,
41179 _swigc__p_wxBitmap,
41180 _swigc__p_wxBitmapDataObject,
41181 _swigc__p_wxBoxSizer,
41182 _swigc__p_wxBusyCursor,
41183 _swigc__p_wxBusyInfo,
41184 _swigc__p_wxCURHandler,
41185 _swigc__p_wxCaret,
41186 _swigc__p_wxChar,
41187 _swigc__p_wxChildFocusEvent,
41188 _swigc__p_wxClipboard,
41189 _swigc__p_wxClipboardLocker,
41190 _swigc__p_wxClipboardTextEvent,
41191 _swigc__p_wxCloseEvent,
41192 _swigc__p_wxColour,
41193 _swigc__p_wxCommandEvent,
41194 _swigc__p_wxConfig,
41195 _swigc__p_wxConfigBase,
41196 _swigc__p_wxConfigPathChanger,
41197 _swigc__p_wxContextMenuEvent,
41198 _swigc__p_wxControl,
41199 _swigc__p_wxControlWithItems,
41200 _swigc__p_wxCursor,
41201 _swigc__p_wxCustomDataObject,
41202 _swigc__p_wxDC,
41203 _swigc__p_wxDataFormat,
41204 _swigc__p_wxDataObject,
41205 _swigc__p_wxDataObjectComposite,
41206 _swigc__p_wxDataObjectSimple,
41207 _swigc__p_wxDateEvent,
41208 _swigc__p_wxDateSpan,
41209 _swigc__p_wxDateTime,
41210 _swigc__p_wxDateTime__TimeZone,
41211 _swigc__p_wxDisplay,
41212 _swigc__p_wxDisplayChangedEvent,
41213 _swigc__p_wxDropFilesEvent,
41214 _swigc__p_wxDuplexMode,
41215 _swigc__p_wxEraseEvent,
41216 _swigc__p_wxEvent,
41217 _swigc__p_wxEvtHandler,
41218 _swigc__p_wxFSFile,
41219 _swigc__p_wxFileConfig,
41220 _swigc__p_wxFileDataObject,
41221 _swigc__p_wxFileHistory,
41222 _swigc__p_wxFileSystem,
41223 _swigc__p_wxFileType,
41224 _swigc__p_wxFileTypeInfo,
41225 _swigc__p_wxFlexGridSizer,
41226 _swigc__p_wxFocusEvent,
41227 _swigc__p_wxFont,
41228 _swigc__p_wxFrame,
41229 _swigc__p_wxGBSizerItem,
41230 _swigc__p_wxGIFHandler,
41231 _swigc__p_wxGridBagSizer,
41232 _swigc__p_wxGridSizer,
41233 _swigc__p_wxICOHandler,
41234 _swigc__p_wxIcon,
41235 _swigc__p_wxIconizeEvent,
41236 _swigc__p_wxIdleEvent,
41237 _swigc__p_wxImage,
41238 _swigc__p_wxImageHandler,
41239 _swigc__p_wxIndividualLayoutConstraint,
41240 _swigc__p_wxInitDialogEvent,
41241 _swigc__p_wxJPEGHandler,
41242 _swigc__p_wxJoystick,
41243 _swigc__p_wxJoystickEvent,
41244 _swigc__p_wxKeyEvent,
41245 _swigc__p_wxKillError,
41246 _swigc__p_wxLayoutConstraints,
41247 _swigc__p_wxLog,
41248 _swigc__p_wxLogBuffer,
41249 _swigc__p_wxLogChain,
41250 _swigc__p_wxLogGui,
41251 _swigc__p_wxLogNull,
41252 _swigc__p_wxLogStderr,
41253 _swigc__p_wxLogTextCtrl,
41254 _swigc__p_wxLogWindow,
41255 _swigc__p_wxMaximizeEvent,
41256 _swigc__p_wxMenu,
41257 _swigc__p_wxMenuBar,
41258 _swigc__p_wxMenuEvent,
41259 _swigc__p_wxMenuItem,
41260 _swigc__p_wxMetafileDataObject,
41261 _swigc__p_wxMimeTypesManager,
41262 _swigc__p_wxMouseCaptureChangedEvent,
41263 _swigc__p_wxMouseCaptureLostEvent,
41264 _swigc__p_wxMouseEvent,
41265 _swigc__p_wxMouseState,
41266 _swigc__p_wxMoveEvent,
41267 _swigc__p_wxMutexGuiLocker,
41268 _swigc__p_wxNavigationKeyEvent,
41269 _swigc__p_wxNcPaintEvent,
41270 _swigc__p_wxNotifyEvent,
41271 _swigc__p_wxObject,
41272 _swigc__p_wxOutputStream,
41273 _swigc__p_wxPCXHandler,
41274 _swigc__p_wxPNGHandler,
41275 _swigc__p_wxPNMHandler,
41276 _swigc__p_wxPaintEvent,
41277 _swigc__p_wxPaletteChangedEvent,
41278 _swigc__p_wxPaperSize,
41279 _swigc__p_wxPlatformInfo,
41280 _swigc__p_wxPoint,
41281 _swigc__p_wxPowerEvent,
41282 _swigc__p_wxProcessEvent,
41283 _swigc__p_wxPyApp,
41284 _swigc__p_wxPyArtProvider,
41285 _swigc__p_wxPyBitmapDataObject,
41286 _swigc__p_wxPyCommandEvent,
41287 _swigc__p_wxPyDataObjectSimple,
41288 _swigc__p_wxPyDropSource,
41289 _swigc__p_wxPyDropTarget,
41290 _swigc__p_wxPyEvent,
41291 _swigc__p_wxPyFileDropTarget,
41292 _swigc__p_wxPyImageHandler,
41293 _swigc__p_wxPyLog,
41294 _swigc__p_wxPyProcess,
41295 _swigc__p_wxPySizer,
41296 _swigc__p_wxPyTextDataObject,
41297 _swigc__p_wxPyTextDropTarget,
41298 _swigc__p_wxPyTimer,
41299 _swigc__p_wxPyTipProvider,
41300 _swigc__p_wxPyValidator,
41301 _swigc__p_wxQueryNewPaletteEvent,
41302 _swigc__p_wxRect,
41303 _swigc__p_wxScrollEvent,
41304 _swigc__p_wxScrollWinEvent,
41305 _swigc__p_wxSetCursorEvent,
41306 _swigc__p_wxShowEvent,
41307 _swigc__p_wxSingleInstanceChecker,
41308 _swigc__p_wxSize,
41309 _swigc__p_wxSizeEvent,
41310 _swigc__p_wxSizer,
41311 _swigc__p_wxSizerItem,
41312 _swigc__p_wxSound,
41313 _swigc__p_wxStandardPaths,
41314 _swigc__p_wxStaticBoxSizer,
41315 _swigc__p_wxStdDialogButtonSizer,
41316 _swigc__p_wxStopWatch,
41317 _swigc__p_wxString,
41318 _swigc__p_wxSysColourChangedEvent,
41319 _swigc__p_wxSystemOptions,
41320 _swigc__p_wxSystemSettings,
41321 _swigc__p_wxTGAHandler,
41322 _swigc__p_wxTIFFHandler,
41323 _swigc__p_wxTextCtrl,
41324 _swigc__p_wxTextDataObject,
41325 _swigc__p_wxTimeSpan,
41326 _swigc__p_wxTimer,
41327 _swigc__p_wxTimerEvent,
41328 _swigc__p_wxTimerRunner,
41329 _swigc__p_wxTipProvider,
41330 _swigc__p_wxToolTip,
41331 _swigc__p_wxURLDataObject,
41332 _swigc__p_wxUpdateUIEvent,
41333 _swigc__p_wxValidator,
41334 _swigc__p_wxVideoMode,
41335 _swigc__p_wxWindow,
41336 _swigc__p_wxWindowCreateEvent,
41337 _swigc__p_wxWindowDestroyEvent,
41338 _swigc__p_wxWindowDisabler,
41339 _swigc__p_wxXPMHandler,
41340 };
41341
41342
41343 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
41344
41345 static swig_const_info swig_const_table[] = {
41346 {0, 0, 0, 0.0, 0, 0}};
41347
41348 #ifdef __cplusplus
41349 }
41350 #endif
41351 /* -----------------------------------------------------------------------------
41352 * Type initialization:
41353 * This problem is tough by the requirement that no dynamic
41354 * memory is used. Also, since swig_type_info structures store pointers to
41355 * swig_cast_info structures and swig_cast_info structures store pointers back
41356 * to swig_type_info structures, we need some lookup code at initialization.
41357 * The idea is that swig generates all the structures that are needed.
41358 * The runtime then collects these partially filled structures.
41359 * The SWIG_InitializeModule function takes these initial arrays out of
41360 * swig_module, and does all the lookup, filling in the swig_module.types
41361 * array with the correct data and linking the correct swig_cast_info
41362 * structures together.
41363 *
41364 * The generated swig_type_info structures are assigned staticly to an initial
41365 * array. We just loop though that array, and handle each type individually.
41366 * First we lookup if this type has been already loaded, and if so, use the
41367 * loaded structure instead of the generated one. Then we have to fill in the
41368 * cast linked list. The cast data is initially stored in something like a
41369 * two-dimensional array. Each row corresponds to a type (there are the same
41370 * number of rows as there are in the swig_type_initial array). Each entry in
41371 * a column is one of the swig_cast_info structures for that type.
41372 * The cast_initial array is actually an array of arrays, because each row has
41373 * a variable number of columns. So to actually build the cast linked list,
41374 * we find the array of casts associated with the type, and loop through it
41375 * adding the casts to the list. The one last trick we need to do is making
41376 * sure the type pointer in the swig_cast_info struct is correct.
41377 *
41378 * First off, we lookup the cast->type name to see if it is already loaded.
41379 * There are three cases to handle:
41380 * 1) If the cast->type has already been loaded AND the type we are adding
41381 * casting info to has not been loaded (it is in this module), THEN we
41382 * replace the cast->type pointer with the type pointer that has already
41383 * been loaded.
41384 * 2) If BOTH types (the one we are adding casting info to, and the
41385 * cast->type) are loaded, THEN the cast info has already been loaded by
41386 * the previous module so we just ignore it.
41387 * 3) Finally, if cast->type has not already been loaded, then we add that
41388 * swig_cast_info to the linked list (because the cast->type) pointer will
41389 * be correct.
41390 * ----------------------------------------------------------------------------- */
41391
41392 #ifdef __cplusplus
41393 extern "C" {
41394 #if 0
41395 } /* c-mode */
41396 #endif
41397 #endif
41398
41399 #if 0
41400 #define SWIGRUNTIME_DEBUG
41401 #endif
41402
41403 SWIGRUNTIME void
41404 SWIG_InitializeModule(void *clientdata) {
41405 size_t i;
41406 swig_module_info *module_head;
41407 static int init_run = 0;
41408
41409 clientdata = clientdata;
41410
41411 if (init_run) return;
41412 init_run = 1;
41413
41414 /* Initialize the swig_module */
41415 swig_module.type_initial = swig_type_initial;
41416 swig_module.cast_initial = swig_cast_initial;
41417
41418 /* Try and load any already created modules */
41419 module_head = SWIG_GetModule(clientdata);
41420 if (module_head) {
41421 swig_module.next = module_head->next;
41422 module_head->next = &swig_module;
41423 } else {
41424 /* This is the first module loaded */
41425 swig_module.next = &swig_module;
41426 SWIG_SetModule(clientdata, &swig_module);
41427 }
41428
41429 /* Now work on filling in swig_module.types */
41430 #ifdef SWIGRUNTIME_DEBUG
41431 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
41432 #endif
41433 for (i = 0; i < swig_module.size; ++i) {
41434 swig_type_info *type = 0;
41435 swig_type_info *ret;
41436 swig_cast_info *cast;
41437
41438 #ifdef SWIGRUNTIME_DEBUG
41439 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41440 #endif
41441
41442 /* if there is another module already loaded */
41443 if (swig_module.next != &swig_module) {
41444 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
41445 }
41446 if (type) {
41447 /* Overwrite clientdata field */
41448 #ifdef SWIGRUNTIME_DEBUG
41449 printf("SWIG_InitializeModule: found type %s\n", type->name);
41450 #endif
41451 if (swig_module.type_initial[i]->clientdata) {
41452 type->clientdata = swig_module.type_initial[i]->clientdata;
41453 #ifdef SWIGRUNTIME_DEBUG
41454 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
41455 #endif
41456 }
41457 } else {
41458 type = swig_module.type_initial[i];
41459 }
41460
41461 /* Insert casting types */
41462 cast = swig_module.cast_initial[i];
41463 while (cast->type) {
41464 /* Don't need to add information already in the list */
41465 ret = 0;
41466 #ifdef SWIGRUNTIME_DEBUG
41467 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
41468 #endif
41469 if (swig_module.next != &swig_module) {
41470 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
41471 #ifdef SWIGRUNTIME_DEBUG
41472 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
41473 #endif
41474 }
41475 if (ret) {
41476 if (type == swig_module.type_initial[i]) {
41477 #ifdef SWIGRUNTIME_DEBUG
41478 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
41479 #endif
41480 cast->type = ret;
41481 ret = 0;
41482 } else {
41483 /* Check for casting already in the list */
41484 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
41485 #ifdef SWIGRUNTIME_DEBUG
41486 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
41487 #endif
41488 if (!ocast) ret = 0;
41489 }
41490 }
41491
41492 if (!ret) {
41493 #ifdef SWIGRUNTIME_DEBUG
41494 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
41495 #endif
41496 if (type->cast) {
41497 type->cast->prev = cast;
41498 cast->next = type->cast;
41499 }
41500 type->cast = cast;
41501 }
41502 cast++;
41503 }
41504 /* Set entry in modules->types array equal to the type */
41505 swig_module.types[i] = type;
41506 }
41507 swig_module.types[i] = 0;
41508
41509 #ifdef SWIGRUNTIME_DEBUG
41510 printf("**** SWIG_InitializeModule: Cast List ******\n");
41511 for (i = 0; i < swig_module.size; ++i) {
41512 int j = 0;
41513 swig_cast_info *cast = swig_module.cast_initial[i];
41514 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
41515 while (cast->type) {
41516 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
41517 cast++;
41518 ++j;
41519 }
41520 printf("---- Total casts: %d\n",j);
41521 }
41522 printf("**** SWIG_InitializeModule: Cast List ******\n");
41523 #endif
41524 }
41525
41526 /* This function will propagate the clientdata field of type to
41527 * any new swig_type_info structures that have been added into the list
41528 * of equivalent types. It is like calling
41529 * SWIG_TypeClientData(type, clientdata) a second time.
41530 */
41531 SWIGRUNTIME void
41532 SWIG_PropagateClientData(void) {
41533 size_t i;
41534 swig_cast_info *equiv;
41535 static int init_run = 0;
41536
41537 if (init_run) return;
41538 init_run = 1;
41539
41540 for (i = 0; i < swig_module.size; i++) {
41541 if (swig_module.types[i]->clientdata) {
41542 equiv = swig_module.types[i]->cast;
41543 while (equiv) {
41544 if (!equiv->converter) {
41545 if (equiv->type && !equiv->type->clientdata)
41546 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
41547 }
41548 equiv = equiv->next;
41549 }
41550 }
41551 }
41552 }
41553
41554 #ifdef __cplusplus
41555 #if 0
41556 {
41557 /* c-mode */
41558 #endif
41559 }
41560 #endif
41561
41562
41563
41564 #ifdef __cplusplus
41565 extern "C" {
41566 #endif
41567
41568 /* Python-specific SWIG API */
41569 #define SWIG_newvarlink() SWIG_Python_newvarlink()
41570 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
41571 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
41572
41573 /* -----------------------------------------------------------------------------
41574 * global variable support code.
41575 * ----------------------------------------------------------------------------- */
41576
41577 typedef struct swig_globalvar {
41578 char *name; /* Name of global variable */
41579 PyObject *(*get_attr)(void); /* Return the current value */
41580 int (*set_attr)(PyObject *); /* Set the value */
41581 struct swig_globalvar *next;
41582 } swig_globalvar;
41583
41584 typedef struct swig_varlinkobject {
41585 PyObject_HEAD
41586 swig_globalvar *vars;
41587 } swig_varlinkobject;
41588
41589 SWIGINTERN PyObject *
41590 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
41591 return PyString_FromString("<Swig global variables>");
41592 }
41593
41594 SWIGINTERN PyObject *
41595 swig_varlink_str(swig_varlinkobject *v) {
41596 PyObject *str = PyString_FromString("(");
41597 swig_globalvar *var;
41598 for (var = v->vars; var; var=var->next) {
41599 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
41600 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
41601 }
41602 PyString_ConcatAndDel(&str,PyString_FromString(")"));
41603 return str;
41604 }
41605
41606 SWIGINTERN int
41607 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
41608 PyObject *str = swig_varlink_str(v);
41609 fprintf(fp,"Swig global variables ");
41610 fprintf(fp,"%s\n", PyString_AsString(str));
41611 Py_DECREF(str);
41612 return 0;
41613 }
41614
41615 SWIGINTERN void
41616 swig_varlink_dealloc(swig_varlinkobject *v) {
41617 swig_globalvar *var = v->vars;
41618 while (var) {
41619 swig_globalvar *n = var->next;
41620 free(var->name);
41621 free(var);
41622 var = n;
41623 }
41624 }
41625
41626 SWIGINTERN PyObject *
41627 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
41628 PyObject *res = NULL;
41629 swig_globalvar *var = v->vars;
41630 while (var) {
41631 if (strcmp(var->name,n) == 0) {
41632 res = (*var->get_attr)();
41633 break;
41634 }
41635 var = var->next;
41636 }
41637 if (res == NULL && !PyErr_Occurred()) {
41638 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41639 }
41640 return res;
41641 }
41642
41643 SWIGINTERN int
41644 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
41645 int res = 1;
41646 swig_globalvar *var = v->vars;
41647 while (var) {
41648 if (strcmp(var->name,n) == 0) {
41649 res = (*var->set_attr)(p);
41650 break;
41651 }
41652 var = var->next;
41653 }
41654 if (res == 1 && !PyErr_Occurred()) {
41655 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
41656 }
41657 return res;
41658 }
41659
41660 SWIGINTERN PyTypeObject*
41661 swig_varlink_type(void) {
41662 static char varlink__doc__[] = "Swig var link object";
41663 static PyTypeObject varlink_type;
41664 static int type_init = 0;
41665 if (!type_init) {
41666 const PyTypeObject tmp
41667 = {
41668 PyObject_HEAD_INIT(NULL)
41669 0, /* Number of items in variable part (ob_size) */
41670 (char *)"swigvarlink", /* Type name (tp_name) */
41671 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
41672 0, /* Itemsize (tp_itemsize) */
41673 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
41674 (printfunc) swig_varlink_print, /* Print (tp_print) */
41675 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
41676 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
41677 0, /* tp_compare */
41678 (reprfunc) swig_varlink_repr, /* tp_repr */
41679 0, /* tp_as_number */
41680 0, /* tp_as_sequence */
41681 0, /* tp_as_mapping */
41682 0, /* tp_hash */
41683 0, /* tp_call */
41684 (reprfunc)swig_varlink_str, /* tp_str */
41685 0, /* tp_getattro */
41686 0, /* tp_setattro */
41687 0, /* tp_as_buffer */
41688 0, /* tp_flags */
41689 varlink__doc__, /* tp_doc */
41690 0, /* tp_traverse */
41691 0, /* tp_clear */
41692 0, /* tp_richcompare */
41693 0, /* tp_weaklistoffset */
41694 #if PY_VERSION_HEX >= 0x02020000
41695 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
41696 #endif
41697 #if PY_VERSION_HEX >= 0x02030000
41698 0, /* tp_del */
41699 #endif
41700 #ifdef COUNT_ALLOCS
41701 0,0,0,0 /* tp_alloc -> tp_next */
41702 #endif
41703 };
41704 varlink_type = tmp;
41705 varlink_type.ob_type = &PyType_Type;
41706 type_init = 1;
41707 }
41708 return &varlink_type;
41709 }
41710
41711 /* Create a variable linking object for use later */
41712 SWIGINTERN PyObject *
41713 SWIG_Python_newvarlink(void) {
41714 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
41715 if (result) {
41716 result->vars = 0;
41717 }
41718 return ((PyObject*) result);
41719 }
41720
41721 SWIGINTERN void
41722 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
41723 swig_varlinkobject *v = (swig_varlinkobject *) p;
41724 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
41725 if (gv) {
41726 size_t size = strlen(name)+1;
41727 gv->name = (char *)malloc(size);
41728 if (gv->name) {
41729 strncpy(gv->name,name,size);
41730 gv->get_attr = get_attr;
41731 gv->set_attr = set_attr;
41732 gv->next = v->vars;
41733 }
41734 }
41735 v->vars = gv;
41736 }
41737
41738 SWIGINTERN PyObject *
41739 SWIG_globals() {
41740 static PyObject *_SWIG_globals = 0;
41741 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
41742 return _SWIG_globals;
41743 }
41744
41745 /* -----------------------------------------------------------------------------
41746 * constants/methods manipulation
41747 * ----------------------------------------------------------------------------- */
41748
41749 /* Install Constants */
41750 SWIGINTERN void
41751 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
41752 PyObject *obj = 0;
41753 size_t i;
41754 for (i = 0; constants[i].type; ++i) {
41755 switch(constants[i].type) {
41756 case SWIG_PY_POINTER:
41757 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
41758 break;
41759 case SWIG_PY_BINARY:
41760 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
41761 break;
41762 default:
41763 obj = 0;
41764 break;
41765 }
41766 if (obj) {
41767 PyDict_SetItemString(d, constants[i].name, obj);
41768 Py_DECREF(obj);
41769 }
41770 }
41771 }
41772
41773 /* -----------------------------------------------------------------------------*/
41774 /* Fix SwigMethods to carry the callback ptrs when needed */
41775 /* -----------------------------------------------------------------------------*/
41776
41777 SWIGINTERN void
41778 SWIG_Python_FixMethods(PyMethodDef *methods,
41779 swig_const_info *const_table,
41780 swig_type_info **types,
41781 swig_type_info **types_initial) {
41782 size_t i;
41783 for (i = 0; methods[i].ml_name; ++i) {
41784 const char *c = methods[i].ml_doc;
41785 if (c && (c = strstr(c, "swig_ptr: "))) {
41786 int j;
41787 swig_const_info *ci = 0;
41788 const char *name = c + 10;
41789 for (j = 0; const_table[j].type; ++j) {
41790 if (strncmp(const_table[j].name, name,
41791 strlen(const_table[j].name)) == 0) {
41792 ci = &(const_table[j]);
41793 break;
41794 }
41795 }
41796 if (ci) {
41797 size_t shift = (ci->ptype) - types;
41798 swig_type_info *ty = types_initial[shift];
41799 size_t ldoc = (c - methods[i].ml_doc);
41800 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
41801 char *ndoc = (char*)malloc(ldoc + lptr + 10);
41802 if (ndoc) {
41803 char *buff = ndoc;
41804 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
41805 if (ptr) {
41806 strncpy(buff, methods[i].ml_doc, ldoc);
41807 buff += ldoc;
41808 strncpy(buff, "swig_ptr: ", 10);
41809 buff += 10;
41810 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
41811 methods[i].ml_doc = ndoc;
41812 }
41813 }
41814 }
41815 }
41816 }
41817 }
41818
41819 #ifdef __cplusplus
41820 }
41821 #endif
41822
41823 /* -----------------------------------------------------------------------------*
41824 * Partial Init method
41825 * -----------------------------------------------------------------------------*/
41826
41827 #ifdef __cplusplus
41828 extern "C"
41829 #endif
41830 SWIGEXPORT void SWIG_init(void) {
41831 PyObject *m, *d;
41832
41833 /* Fix SwigMethods to carry the callback ptrs when needed */
41834 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
41835
41836 m = Py_InitModule((char *) SWIG_name, SwigMethods);
41837 d = PyModule_GetDict(m);
41838
41839 SWIG_InitializeModule(0);
41840 SWIG_InstallConstants(d,swig_const_table);
41841
41842
41843 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
41844 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
41845 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
41846 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
41847 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
41848 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
41849 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
41850 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
41851 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
41852 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
41853 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
41854 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
41855 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
41856 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
41857 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
41858 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
41859 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
41860 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
41861 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
41862 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
41863 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
41864 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
41865 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
41866 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
41867 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
41868 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
41869 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
41870 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
41871 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
41872 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
41873 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
41874 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
41875 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
41876 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
41877 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
41878 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
41879 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
41880 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
41881 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
41882 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
41883 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
41884 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
41885 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
41886 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
41887 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
41888 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
41889 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
41890 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
41891 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
41892 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
41893 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
41894 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
41895 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
41896 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
41897 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
41898 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
41899 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
41900 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
41901 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
41902 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
41903 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
41904 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
41905 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
41906 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
41907 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
41908 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
41909 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
41910 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
41911 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
41912 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
41913 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
41914 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
41915 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
41916 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
41917 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
41918 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
41919 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
41920 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
41921 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
41922 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
41923 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
41924 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
41925 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
41926 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
41927 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
41928 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
41929 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
41930 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
41931 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
41932 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
41933 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
41934 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
41935 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
41936 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
41937 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
41938 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
41939 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
41940 SWIG_Python_SetConstant(d, "STOCK_NOFLAGS",SWIG_From_int(static_cast< int >(wxSTOCK_NOFLAGS)));
41941 SWIG_Python_SetConstant(d, "STOCK_WITH_MNEMONIC",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_MNEMONIC)));
41942 SWIG_Python_SetConstant(d, "STOCK_WITH_ACCELERATOR",SWIG_From_int(static_cast< int >(wxSTOCK_WITH_ACCELERATOR)));
41943 SWIG_Python_SetConstant(d, "STOCK_MENU",SWIG_From_int(static_cast< int >(wxSTOCK_MENU)));
41944 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
41945 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
41946 SWIG_Python_SetConstant(d, "OS_UNKNOWN",SWIG_From_int(static_cast< int >(wxOS_UNKNOWN)));
41947 SWIG_Python_SetConstant(d, "OS_MAC_OS",SWIG_From_int(static_cast< int >(wxOS_MAC_OS)));
41948 SWIG_Python_SetConstant(d, "OS_MAC_OSX_DARWIN",SWIG_From_int(static_cast< int >(wxOS_MAC_OSX_DARWIN)));
41949 SWIG_Python_SetConstant(d, "OS_MAC",SWIG_From_int(static_cast< int >(wxOS_MAC)));
41950 SWIG_Python_SetConstant(d, "OS_WINDOWS_9X",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_9X)));
41951 SWIG_Python_SetConstant(d, "OS_WINDOWS_NT",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_NT)));
41952 SWIG_Python_SetConstant(d, "OS_WINDOWS_MICRO",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_MICRO)));
41953 SWIG_Python_SetConstant(d, "OS_WINDOWS_CE",SWIG_From_int(static_cast< int >(wxOS_WINDOWS_CE)));
41954 SWIG_Python_SetConstant(d, "OS_WINDOWS",SWIG_From_int(static_cast< int >(wxOS_WINDOWS)));
41955 SWIG_Python_SetConstant(d, "OS_UNIX_LINUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_LINUX)));
41956 SWIG_Python_SetConstant(d, "OS_UNIX_FREEBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_FREEBSD)));
41957 SWIG_Python_SetConstant(d, "OS_UNIX_OPENBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_OPENBSD)));
41958 SWIG_Python_SetConstant(d, "OS_UNIX_NETBSD",SWIG_From_int(static_cast< int >(wxOS_UNIX_NETBSD)));
41959 SWIG_Python_SetConstant(d, "OS_UNIX_SOLARIS",SWIG_From_int(static_cast< int >(wxOS_UNIX_SOLARIS)));
41960 SWIG_Python_SetConstant(d, "OS_UNIX_AIX",SWIG_From_int(static_cast< int >(wxOS_UNIX_AIX)));
41961 SWIG_Python_SetConstant(d, "OS_UNIX_HPUX",SWIG_From_int(static_cast< int >(wxOS_UNIX_HPUX)));
41962 SWIG_Python_SetConstant(d, "OS_UNIX",SWIG_From_int(static_cast< int >(wxOS_UNIX)));
41963 SWIG_Python_SetConstant(d, "OS_DOS",SWIG_From_int(static_cast< int >(wxOS_DOS)));
41964 SWIG_Python_SetConstant(d, "OS_OS2",SWIG_From_int(static_cast< int >(wxOS_OS2)));
41965 SWIG_Python_SetConstant(d, "PORT_UNKNOWN",SWIG_From_int(static_cast< int >(wxPORT_UNKNOWN)));
41966 SWIG_Python_SetConstant(d, "PORT_BASE",SWIG_From_int(static_cast< int >(wxPORT_BASE)));
41967 SWIG_Python_SetConstant(d, "PORT_MSW",SWIG_From_int(static_cast< int >(wxPORT_MSW)));
41968 SWIG_Python_SetConstant(d, "PORT_MOTIF",SWIG_From_int(static_cast< int >(wxPORT_MOTIF)));
41969 SWIG_Python_SetConstant(d, "PORT_GTK",SWIG_From_int(static_cast< int >(wxPORT_GTK)));
41970 SWIG_Python_SetConstant(d, "PORT_MGL",SWIG_From_int(static_cast< int >(wxPORT_MGL)));
41971 SWIG_Python_SetConstant(d, "PORT_X11",SWIG_From_int(static_cast< int >(wxPORT_X11)));
41972 SWIG_Python_SetConstant(d, "PORT_PM",SWIG_From_int(static_cast< int >(wxPORT_PM)));
41973 SWIG_Python_SetConstant(d, "PORT_OS2",SWIG_From_int(static_cast< int >(wxPORT_OS2)));
41974 SWIG_Python_SetConstant(d, "PORT_MAC",SWIG_From_int(static_cast< int >(wxPORT_MAC)));
41975 SWIG_Python_SetConstant(d, "PORT_COCOA",SWIG_From_int(static_cast< int >(wxPORT_COCOA)));
41976 SWIG_Python_SetConstant(d, "PORT_WINCE",SWIG_From_int(static_cast< int >(wxPORT_WINCE)));
41977 SWIG_Python_SetConstant(d, "PORT_PALMOS",SWIG_From_int(static_cast< int >(wxPORT_PALMOS)));
41978 SWIG_Python_SetConstant(d, "PORT_DFB",SWIG_From_int(static_cast< int >(wxPORT_DFB)));
41979 SWIG_Python_SetConstant(d, "ARCH_INVALID",SWIG_From_int(static_cast< int >(wxARCH_INVALID)));
41980 SWIG_Python_SetConstant(d, "ARCH_32",SWIG_From_int(static_cast< int >(wxARCH_32)));
41981 SWIG_Python_SetConstant(d, "ARCH_64",SWIG_From_int(static_cast< int >(wxARCH_64)));
41982 SWIG_Python_SetConstant(d, "ARCH_MAX",SWIG_From_int(static_cast< int >(wxARCH_MAX)));
41983 SWIG_Python_SetConstant(d, "ENDIAN_INVALID",SWIG_From_int(static_cast< int >(wxENDIAN_INVALID)));
41984 SWIG_Python_SetConstant(d, "ENDIAN_BIG",SWIG_From_int(static_cast< int >(wxENDIAN_BIG)));
41985 SWIG_Python_SetConstant(d, "ENDIAN_LITTLE",SWIG_From_int(static_cast< int >(wxENDIAN_LITTLE)));
41986 SWIG_Python_SetConstant(d, "ENDIAN_PDP",SWIG_From_int(static_cast< int >(wxENDIAN_PDP)));
41987 SWIG_Python_SetConstant(d, "ENDIAN_MAX",SWIG_From_int(static_cast< int >(wxENDIAN_MAX)));
41988 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
41989 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
41990 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
41991
41992 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
41993
41994 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
41995 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
41996 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
41997 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
41998 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
41999 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
42000 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
42001 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
42002 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
42003 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
42004 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
42005 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
42006 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
42007 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
42008 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
42009 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
42010 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
42011 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
42012 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
42013 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
42014 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
42015 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
42016 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
42017 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
42018 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
42019 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
42020 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
42021 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
42022 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
42023 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
42024 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
42025 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
42026 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
42027 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
42028 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
42029 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
42030 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
42031 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
42032 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
42033 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
42034 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
42035 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
42036 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
42037 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
42038 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
42039 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
42040 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
42041 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
42042 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
42043 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
42044 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
42045 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
42046 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
42047
42048 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
42049
42050 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
42051 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
42052 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
42053 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
42054 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
42055 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
42056 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
42057 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
42058 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
42059 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
42060 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
42061 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
42062 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
42063 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
42064 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
42065 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
42066 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
42067 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
42068 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
42069 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
42070 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
42071 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
42072 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
42073 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
42074 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
42075 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
42076 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
42077 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
42078 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
42079 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
42080 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
42081 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
42082 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
42083 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
42084 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
42085 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
42086 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
42087 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
42088 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
42089 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
42090 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
42091 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
42092 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
42093 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
42094 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
42095 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
42096 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
42097 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
42098 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
42099 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
42100 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
42101 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
42102 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
42103 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
42104 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
42105 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
42106 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
42107 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
42108 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
42109 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
42110 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
42111 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
42112 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
42113 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
42114 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
42115 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
42116 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
42117 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
42118 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
42119 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
42120 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
42121 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
42122 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
42123 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
42124 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
42125 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
42126
42127 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
42128
42129 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
42130 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
42131 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
42132 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
42133 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
42134 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
42135 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
42136 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
42137 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
42138 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
42139 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
42140 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
42141 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
42142 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
42143 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
42144 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
42145 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
42146 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
42147 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
42148 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
42149 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
42150 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
42151 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
42152 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
42153 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
42154 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
42155 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
42156 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
42157 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
42158 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
42159 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
42160 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
42161 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
42162 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
42163 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
42164 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
42165 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
42166 SWIG_Python_SetConstant(d, "DateTime_GMT13",SWIG_From_int(static_cast< int >(wxDateTime::GMT13)));
42167 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
42168 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
42169 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
42170 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
42171 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
42172 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
42173 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
42174 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
42175 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
42176 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
42177 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
42178 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
42179 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
42180 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
42181 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
42182 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
42183 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
42184 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
42185 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
42186 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
42187 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
42188 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
42189 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
42190 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
42191 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
42192 SWIG_Python_SetConstant(d, "DateTime_NZST",SWIG_From_int(static_cast< int >(wxDateTime::NZST)));
42193 SWIG_Python_SetConstant(d, "DateTime_NZDT",SWIG_From_int(static_cast< int >(wxDateTime::NZDT)));
42194 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
42195 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
42196 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
42197 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
42198 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
42199 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
42200 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
42201 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
42202 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
42203 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
42204 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
42205 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
42206 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
42207 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
42208 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
42209 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
42210 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
42211 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
42212 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
42213 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
42214 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
42215 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
42216 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
42217 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
42218 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
42219 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
42220 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
42221 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
42222 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
42223 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
42224 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
42225 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
42226 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
42227 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
42228 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
42229 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
42230 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
42231 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
42232 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
42233 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
42234 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
42235 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
42236 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
42237 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
42238 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
42239 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
42240 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
42241 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
42242 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
42243 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
42244 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
42245 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
42246 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
42247 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
42248 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
42249 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
42250 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
42251 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
42252 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
42253 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
42254 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
42255 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
42256 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
42257 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
42258 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
42259 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
42260 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
42261 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
42262 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
42263 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
42264 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
42265 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
42266 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
42267 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
42268 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
42269 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
42270 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
42271 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
42272 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
42273 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
42274 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
42275 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
42276 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
42277 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
42278 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
42279 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
42280 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
42281 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
42282 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
42283 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
42284 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
42285 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
42286 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
42287 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
42288 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
42289 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
42290 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
42291 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
42292 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
42293 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
42294 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
42295 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
42296 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
42297 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
42298 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
42299 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
42300 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
42301 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
42302 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
42303 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
42304 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
42305 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
42306 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
42307 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
42308 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
42309 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
42310 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
42311 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
42312 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
42313 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
42314 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
42315 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
42316 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
42317 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
42318 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
42319 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
42320 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
42321 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
42322 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
42323 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
42324 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
42325 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
42326 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
42327 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
42328 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
42329 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
42330 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
42331 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
42332
42333 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
42334 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
42335 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
42336 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
42337
42338 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
42339 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
42340 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
42341 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
42342 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
42343 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
42344 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
42345 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
42346 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
42347 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
42348 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
42349 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
42350 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
42351 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
42352 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
42353 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
42354 }
42355
wxWidgets (Impactor)