]> 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
compilation fix for compilation w/o precompiled headers
[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_wxAcceleratorTable swig_types[8]
2475 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2476 #define SWIGTYPE_p_wxArrayString swig_types[10]
2477 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2478 #define SWIGTYPE_p_wxBitmap swig_types[12]
2479 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2480 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2481 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2482 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2483 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2484 #define SWIGTYPE_p_wxCaret swig_types[18]
2485 #define SWIGTYPE_p_wxChar swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboard swig_types[21]
2488 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2489 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[23]
2490 #define SWIGTYPE_p_wxCloseEvent swig_types[24]
2491 #define SWIGTYPE_p_wxColour swig_types[25]
2492 #define SWIGTYPE_p_wxCommandEvent swig_types[26]
2493 #define SWIGTYPE_p_wxConfig swig_types[27]
2494 #define SWIGTYPE_p_wxConfigBase swig_types[28]
2495 #define SWIGTYPE_p_wxConfigPathChanger swig_types[29]
2496 #define SWIGTYPE_p_wxContextMenuEvent swig_types[30]
2497 #define SWIGTYPE_p_wxControl swig_types[31]
2498 #define SWIGTYPE_p_wxControlWithItems swig_types[32]
2499 #define SWIGTYPE_p_wxCursor swig_types[33]
2500 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
2501 #define SWIGTYPE_p_wxDC swig_types[35]
2502 #define SWIGTYPE_p_wxDataFormat swig_types[36]
2503 #define SWIGTYPE_p_wxDataObject swig_types[37]
2504 #define SWIGTYPE_p_wxDataObjectComposite swig_types[38]
2505 #define SWIGTYPE_p_wxDataObjectSimple swig_types[39]
2506 #define SWIGTYPE_p_wxDateEvent swig_types[40]
2507 #define SWIGTYPE_p_wxDateSpan swig_types[41]
2508 #define SWIGTYPE_p_wxDateTime swig_types[42]
2509 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[43]
2510 #define SWIGTYPE_p_wxDisplay swig_types[44]
2511 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[45]
2512 #define SWIGTYPE_p_wxDropFilesEvent swig_types[46]
2513 #define SWIGTYPE_p_wxDuplexMode swig_types[47]
2514 #define SWIGTYPE_p_wxEraseEvent swig_types[48]
2515 #define SWIGTYPE_p_wxEvent swig_types[49]
2516 #define SWIGTYPE_p_wxEvtHandler swig_types[50]
2517 #define SWIGTYPE_p_wxFSFile swig_types[51]
2518 #define SWIGTYPE_p_wxFileConfig swig_types[52]
2519 #define SWIGTYPE_p_wxFileDataObject swig_types[53]
2520 #define SWIGTYPE_p_wxFileHistory swig_types[54]
2521 #define SWIGTYPE_p_wxFileSystem swig_types[55]
2522 #define SWIGTYPE_p_wxFileType swig_types[56]
2523 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
2524 #define SWIGTYPE_p_wxFlexGridSizer swig_types[58]
2525 #define SWIGTYPE_p_wxFocusEvent swig_types[59]
2526 #define SWIGTYPE_p_wxFont swig_types[60]
2527 #define SWIGTYPE_p_wxFrame swig_types[61]
2528 #define SWIGTYPE_p_wxGBSizerItem swig_types[62]
2529 #define SWIGTYPE_p_wxGIFHandler swig_types[63]
2530 #define SWIGTYPE_p_wxGridBagSizer swig_types[64]
2531 #define SWIGTYPE_p_wxGridSizer swig_types[65]
2532 #define SWIGTYPE_p_wxICOHandler swig_types[66]
2533 #define SWIGTYPE_p_wxIcon swig_types[67]
2534 #define SWIGTYPE_p_wxIconizeEvent swig_types[68]
2535 #define SWIGTYPE_p_wxIdleEvent swig_types[69]
2536 #define SWIGTYPE_p_wxImage swig_types[70]
2537 #define SWIGTYPE_p_wxImageHandler swig_types[71]
2538 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[72]
2539 #define SWIGTYPE_p_wxInitDialogEvent swig_types[73]
2540 #define SWIGTYPE_p_wxJPEGHandler swig_types[74]
2541 #define SWIGTYPE_p_wxJoystick swig_types[75]
2542 #define SWIGTYPE_p_wxJoystickEvent swig_types[76]
2543 #define SWIGTYPE_p_wxKeyEvent swig_types[77]
2544 #define SWIGTYPE_p_wxKillError swig_types[78]
2545 #define SWIGTYPE_p_wxLayoutConstraints swig_types[79]
2546 #define SWIGTYPE_p_wxLog swig_types[80]
2547 #define SWIGTYPE_p_wxLogBuffer swig_types[81]
2548 #define SWIGTYPE_p_wxLogChain swig_types[82]
2549 #define SWIGTYPE_p_wxLogGui swig_types[83]
2550 #define SWIGTYPE_p_wxLogNull swig_types[84]
2551 #define SWIGTYPE_p_wxLogStderr swig_types[85]
2552 #define SWIGTYPE_p_wxLogTextCtrl swig_types[86]
2553 #define SWIGTYPE_p_wxLogWindow swig_types[87]
2554 #define SWIGTYPE_p_wxMaximizeEvent swig_types[88]
2555 #define SWIGTYPE_p_wxMenu swig_types[89]
2556 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2557 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2558 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2559 #define SWIGTYPE_p_wxMetafileDataObject swig_types[93]
2560 #define SWIGTYPE_p_wxMimeTypesManager swig_types[94]
2561 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[95]
2562 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[96]
2563 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2564 #define SWIGTYPE_p_wxMouseState swig_types[98]
2565 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2566 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2567 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2569 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2570 #define SWIGTYPE_p_wxObject swig_types[104]
2571 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2573 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2574 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2575 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2576 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2577 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2578 #define SWIGTYPE_p_wxPoint swig_types[112]
2579 #define SWIGTYPE_p_wxPowerEvent swig_types[113]
2580 #define SWIGTYPE_p_wxProcessEvent swig_types[114]
2581 #define SWIGTYPE_p_wxPyApp swig_types[115]
2582 #define SWIGTYPE_p_wxPyArtProvider swig_types[116]
2583 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[117]
2584 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
2585 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[119]
2586 #define SWIGTYPE_p_wxPyDropSource swig_types[120]
2587 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
2588 #define SWIGTYPE_p_wxPyEvent swig_types[122]
2589 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[123]
2590 #define SWIGTYPE_p_wxPyImageHandler swig_types[124]
2591 #define SWIGTYPE_p_wxPyLog swig_types[125]
2592 #define SWIGTYPE_p_wxPyProcess swig_types[126]
2593 #define SWIGTYPE_p_wxPySizer swig_types[127]
2594 #define SWIGTYPE_p_wxPyTextDataObject swig_types[128]
2595 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[129]
2596 #define SWIGTYPE_p_wxPyTimer swig_types[130]
2597 #define SWIGTYPE_p_wxPyTipProvider swig_types[131]
2598 #define SWIGTYPE_p_wxPyValidator swig_types[132]
2599 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[133]
2600 #define SWIGTYPE_p_wxRect swig_types[134]
2601 #define SWIGTYPE_p_wxScrollEvent swig_types[135]
2602 #define SWIGTYPE_p_wxScrollWinEvent swig_types[136]
2603 #define SWIGTYPE_p_wxSetCursorEvent swig_types[137]
2604 #define SWIGTYPE_p_wxShowEvent swig_types[138]
2605 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[139]
2606 #define SWIGTYPE_p_wxSize swig_types[140]
2607 #define SWIGTYPE_p_wxSizeEvent swig_types[141]
2608 #define SWIGTYPE_p_wxSizer swig_types[142]
2609 #define SWIGTYPE_p_wxSizerItem swig_types[143]
2610 #define SWIGTYPE_p_wxSound swig_types[144]
2611 #define SWIGTYPE_p_wxStandardPaths swig_types[145]
2612 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[146]
2613 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[147]
2614 #define SWIGTYPE_p_wxStopWatch swig_types[148]
2615 #define SWIGTYPE_p_wxString swig_types[149]
2616 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[150]
2617 #define SWIGTYPE_p_wxSystemOptions swig_types[151]
2618 #define SWIGTYPE_p_wxSystemSettings swig_types[152]
2619 #define SWIGTYPE_p_wxTIFFHandler swig_types[153]
2620 #define SWIGTYPE_p_wxTextCtrl swig_types[154]
2621 #define SWIGTYPE_p_wxTextDataObject swig_types[155]
2622 #define SWIGTYPE_p_wxTimeSpan swig_types[156]
2623 #define SWIGTYPE_p_wxTimer swig_types[157]
2624 #define SWIGTYPE_p_wxTimerEvent swig_types[158]
2625 #define SWIGTYPE_p_wxTimerRunner swig_types[159]
2626 #define SWIGTYPE_p_wxTipProvider swig_types[160]
2627 #define SWIGTYPE_p_wxToolTip swig_types[161]
2628 #define SWIGTYPE_p_wxURLDataObject swig_types[162]
2629 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[163]
2630 #define SWIGTYPE_p_wxValidator swig_types[164]
2631 #define SWIGTYPE_p_wxVideoMode swig_types[165]
2632 #define SWIGTYPE_p_wxWindow swig_types[166]
2633 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[167]
2634 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[168]
2635 #define SWIGTYPE_p_wxWindowDisabler swig_types[169]
2636 #define SWIGTYPE_p_wxXPMHandler swig_types[170]
2637 static swig_type_info *swig_types[172];
2638 static swig_module_info swig_module = {swig_types, 171, 0, 0, 0, 0};
2639 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2640 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2641
2642 /* -------- TYPES TABLE (END) -------- */
2643
2644 #if (PY_VERSION_HEX <= 0x02000000)
2645 # if !defined(SWIG_PYTHON_CLASSIC)
2646 # error "This python version requires to use swig with the '-classic' option"
2647 # endif
2648 #endif
2649 #if (PY_VERSION_HEX <= 0x02020000)
2650 # error "This python version requires to use swig with the '-nomodern' option"
2651 #endif
2652 #if (PY_VERSION_HEX <= 0x02020000)
2653 # error "This python version requires to use swig with the '-nomodernargs' option"
2654 #endif
2655 #ifndef METH_O
2656 # error "This python version requires to use swig with the '-nofastunpack' option"
2657 #endif
2658
2659 /*-----------------------------------------------
2660 @(target):= _misc_.so
2661 ------------------------------------------------*/
2662 #define SWIG_init init_misc_
2663
2664 #define SWIG_name "_misc_"
2665
2666 #define SWIGVERSION 0x010329
2667
2668
2669 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2670 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2671
2672
2673 #include <stdexcept>
2674
2675
2676 namespace swig {
2677 class PyObject_ptr {
2678 protected:
2679 PyObject *_obj;
2680
2681 public:
2682 PyObject_ptr() :_obj(0)
2683 {
2684 }
2685
2686 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2687 {
2688 Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2692 {
2693 if (initial_ref) Py_XINCREF(_obj);
2694 }
2695
2696 PyObject_ptr & operator=(const PyObject_ptr& item)
2697 {
2698 Py_XINCREF(item._obj);
2699 Py_XDECREF(_obj);
2700 _obj = item._obj;
2701 return *this;
2702 }
2703
2704 ~PyObject_ptr()
2705 {
2706 Py_XDECREF(_obj);
2707 }
2708
2709 operator PyObject *() const
2710 {
2711 return _obj;
2712 }
2713
2714 PyObject *operator->() const
2715 {
2716 return _obj;
2717 }
2718 };
2719 }
2720
2721
2722 namespace swig {
2723 struct PyObject_var : PyObject_ptr {
2724 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2725
2726 PyObject_var & operator = (PyObject* obj)
2727 {
2728 Py_XDECREF(_obj);
2729 _obj = obj;
2730 return *this;
2731 }
2732 };
2733 }
2734
2735
2736 #include "wx/wxPython/wxPython.h"
2737 #include "wx/wxPython/pyclasses.h"
2738 #include "wx/wxPython/pyistream.h"
2739
2740 static const wxString wxPyEmptyString(wxEmptyString);
2741
2742
2743
2744 #define SWIG_From_long PyInt_FromLong
2745
2746
2747 SWIGINTERNINLINE PyObject *
2748 SWIG_From_int (int value)
2749 {
2750 return SWIG_From_long (value);
2751 }
2752
2753
2754 #include <limits.h>
2755 #ifndef LLONG_MIN
2756 # define LLONG_MIN LONG_LONG_MIN
2757 #endif
2758 #ifndef LLONG_MAX
2759 # define LLONG_MAX LONG_LONG_MAX
2760 #endif
2761 #ifndef ULLONG_MAX
2762 # define ULLONG_MAX ULONG_LONG_MAX
2763 #endif
2764
2765
2766 SWIGINTERN int
2767 SWIG_AsVal_long (PyObject* obj, long* val)
2768 {
2769 if (PyNumber_Check(obj)) {
2770 if (val) *val = PyInt_AsLong(obj);
2771 return SWIG_OK;
2772 }
2773 return SWIG_TypeError;
2774 }
2775
2776
2777 SWIGINTERN int
2778 SWIG_AsVal_int (PyObject * obj, int *val)
2779 {
2780 long v;
2781 int res = SWIG_AsVal_long (obj, &v);
2782 if (SWIG_IsOK(res)) {
2783 if ((v < INT_MIN || v > INT_MAX)) {
2784 return SWIG_OverflowError;
2785 } else {
2786 if (val) *val = static_cast< int >(v);
2787 }
2788 }
2789 return res;
2790 }
2791
2792 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2793
2794 #include <wx/stockitem.h>
2795
2796 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2797 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2798 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2799
2800 SWIGINTERN int
2801 SWIG_AsVal_bool (PyObject *obj, bool *val)
2802 {
2803 if (obj == Py_True) {
2804 if (val) *val = true;
2805 return SWIG_OK;
2806 } else if (obj == Py_False) {
2807 if (val) *val = false;
2808 return SWIG_OK;
2809 } else {
2810 long v = 0;
2811 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2812 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2813 return res;
2814 }
2815 }
2816
2817
2818 wxMemorySize wxGetFreeMemory()
2819 { wxPyRaiseNotImplemented(); return 0; }
2820
2821
2822 SWIGINTERN int
2823 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2824 {
2825 long v = 0;
2826 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2827 return SWIG_TypeError;
2828 }
2829 else if (val)
2830 *val = (unsigned long)v;
2831 return SWIG_OK;
2832 }
2833
2834
2835 SWIGINTERNINLINE PyObject*
2836 SWIG_From_unsigned_SS_long (unsigned long value)
2837 {
2838 return (value > LONG_MAX) ?
2839 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2840 }
2841
2842
2843 void* wxGetXDisplay()
2844 {
2845 #ifdef __WXGTK__
2846 return wxGetDisplay();
2847 #else
2848 return NULL;
2849 #endif
2850 }
2851
2852
2853 wxWindow* FindWindowAtPointer() {
2854 wxPoint unused;
2855 return wxFindWindowAtPointer(unused);
2856 }
2857
2858
2859 void wxWakeUpMainThread() {}
2860
2861
2862 bool wxThread_IsMain() {
2863 #ifdef WXP_WITH_THREAD
2864 return wxThread::IsMain();
2865 #else
2866 return true;
2867 #endif
2868 }
2869
2870 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2871 delete self;
2872 }
2873
2874 #include <wx/snglinst.h>
2875
2876
2877 #ifdef __WXMSW__
2878 #include <wx/msw/private.h>
2879 #include <wx/dynload.h>
2880 #endif
2881
2882
2883
2884 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2885 #if 0
2886 , int method
2887 #endif
2888 )
2889 {
2890 #ifdef __WXMSW__
2891 #if 0
2892 switch (method)
2893 {
2894 case 1:
2895 // This one only partially works. Appears to be an undocumented
2896 // "standard" convention that not all widgets adhear to. For
2897 // example, for some widgets backgrounds or non-client areas may
2898 // not be painted.
2899 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2900 break;
2901
2902 case 2:
2903 #endif
2904 // This one works much better, nearly all widgets and their
2905 // children are captured correctly[**]. Prior to the big
2906 // background erase changes that Vadim did in 2004-2005 this
2907 // method failed badly on XP with Themes activated, most native
2908 // widgets draw only partially, if at all. Without themes it
2909 // worked just like on Win2k. After those changes this method
2910 // works very well.
2911 //
2912 // ** For example the radio buttons in a wxRadioBox are not its
2913 // children by default, but you can capture it via the panel
2914 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2915 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2916 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2917 PRF_ERASEBKGND | PRF_OWNED );
2918 return true;
2919 #if 0
2920 break;
2921
2922 case 3:
2923 // This one is only defined in the latest SDK and is only
2924 // available on XP. MSDN says it is similar to sending WM_PRINT
2925 // so I expect that it will work similar to the above. Since it
2926 // is avaialble only on XP, it can't be compiled like this and
2927 // will have to be loaded dynamically.
2928 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2929
2930 // fall through
2931
2932 case 4:
2933 // Use PrintWindow if available, or fallback to WM_PRINT
2934 // otherwise. Unfortunately using PrintWindow is even worse than
2935 // WM_PRINT. For most native widgets nothing is drawn to the dc
2936 // at all, with or without Themes.
2937 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2938 static bool s_triedToLoad = false;
2939 static PrintWindow_t pfnPrintWindow = NULL;
2940 if ( !s_triedToLoad )
2941 {
2942
2943 s_triedToLoad = true;
2944 wxDynamicLibrary dllUser32(_T("user32.dll"));
2945 if ( dllUser32.IsLoaded() )
2946 {
2947 wxLogNull nolog; // Don't report errors here
2948 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2949 }
2950 }
2951 if (pfnPrintWindow)
2952 {
2953 //printf("Using PrintWindow\n");
2954 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2955 }
2956 else
2957 {
2958 //printf("Using WM_PRINT\n");
2959 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2960 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2961 PRF_ERASEBKGND | PRF_OWNED );
2962 }
2963 }
2964 #endif // 0
2965 #else
2966 return false;
2967 #endif // __WXMSW__
2968 }
2969
2970
2971
2972 #include <wx/tipdlg.h>
2973
2974
2975 SWIGINTERNINLINE PyObject *
2976 SWIG_From_size_t (size_t value)
2977 {
2978 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2979 }
2980
2981
2982 class wxPyTipProvider : public wxTipProvider {
2983 public:
2984 wxPyTipProvider(size_t currentTip)
2985 : wxTipProvider(currentTip) {}
2986
2987 DEC_PYCALLBACK_STRING__pure(GetTip);
2988 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2989 PYPRIVATE;
2990 };
2991
2992 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2993 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2994
2995
2996 SWIGINTERNINLINE int
2997 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2998 {
2999 unsigned long v;
3000 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3001 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3002 return res;
3003 }
3004
3005
3006 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
3007
3008 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
3009
3010 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
3011 : wxTimer(owner, id)
3012 {
3013 if (owner == NULL)
3014 SetOwner(this);
3015 }
3016
3017
3018 SWIGINTERN swig_type_info*
3019 SWIG_pchar_descriptor()
3020 {
3021 static int init = 0;
3022 static swig_type_info* info = 0;
3023 if (!init) {
3024 info = SWIG_TypeQuery("_p_char");
3025 init = 1;
3026 }
3027 return info;
3028 }
3029
3030
3031 SWIGINTERNINLINE PyObject *
3032 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3033 {
3034 if (carray) {
3035 if (size > INT_MAX) {
3036 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3037 return pchar_descriptor ?
3038 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3039 } else {
3040 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3041 }
3042 } else {
3043 return SWIG_Py_Void();
3044 }
3045 }
3046
3047
3048 SWIGINTERNINLINE PyObject *
3049 SWIG_FromCharPtr(const char *cptr)
3050 {
3051 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3052 }
3053
3054
3055 SWIGINTERN int
3056 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3057 {
3058 unsigned long v;
3059 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3060 if (SWIG_IsOK(res)) {
3061 if ((v > UINT_MAX)) {
3062 return SWIG_OverflowError;
3063 } else {
3064 if (val) *val = static_cast< unsigned int >(v);
3065 }
3066 }
3067 return res;
3068 }
3069
3070 SWIGINTERN wxString wxLog_TimeStamp(){
3071 wxString msg;
3072 wxLog::TimeStamp(&msg);
3073 return msg;
3074 }
3075 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3076 // Make some wrappers that double any % signs so they are 'escaped'
3077 void wxPyLogFatalError(const wxString& msg)
3078 {
3079 wxString m(msg);
3080 m.Replace(wxT("%"), wxT("%%"));
3081 wxLogFatalError(m);
3082 }
3083
3084 void wxPyLogError(const wxString& msg)
3085 {
3086 wxString m(msg);
3087 m.Replace(wxT("%"), wxT("%%"));
3088 wxLogError(m);
3089 }
3090
3091 void wxPyLogWarning(const wxString& msg)
3092 {
3093 wxString m(msg);
3094 m.Replace(wxT("%"), wxT("%%"));
3095 wxLogWarning(m);
3096 }
3097
3098 void wxPyLogMessage(const wxString& msg)
3099 {
3100 wxString m(msg);
3101 m.Replace(wxT("%"), wxT("%%"));
3102 wxLogMessage(m);
3103 }
3104
3105 void wxPyLogInfo(const wxString& msg)
3106 {
3107 wxString m(msg);
3108 m.Replace(wxT("%"), wxT("%%"));
3109 wxLogInfo(m);
3110 }
3111
3112 void wxPyLogDebug(const wxString& msg)
3113 {
3114 wxString m(msg);
3115 m.Replace(wxT("%"), wxT("%%"));
3116 wxLogDebug(m);
3117 }
3118
3119 void wxPyLogVerbose(const wxString& msg)
3120 {
3121 wxString m(msg);
3122 m.Replace(wxT("%"), wxT("%%"));
3123 wxLogVerbose(m);
3124 }
3125
3126 void wxPyLogStatus(const wxString& msg)
3127 {
3128 wxString m(msg);
3129 m.Replace(wxT("%"), wxT("%%"));
3130 wxLogStatus(m);
3131 }
3132
3133 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3134 {
3135 wxString m(msg);
3136 m.Replace(wxT("%"), wxT("%%"));
3137 wxLogStatus(pFrame, m);
3138 }
3139
3140 void wxPyLogSysError(const wxString& msg)
3141 {
3142 wxString m(msg);
3143 m.Replace(wxT("%"), wxT("%%"));
3144 wxLogSysError(m);
3145 }
3146
3147 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3148 {
3149 wxString m(msg);
3150 m.Replace(wxT("%"), wxT("%%"));
3151 wxLogGeneric(level, m);
3152 }
3153
3154 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3155 {
3156 wxString m(msg);
3157 m.Replace(wxT("%"), wxT("%%"));
3158 wxLogTrace(mask, m);
3159 }
3160
3161 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3162 {
3163 wxString m(msg);
3164 m.Replace(wxT("%"), wxT("%%"));
3165 wxLogTrace(mask, m);
3166 }
3167
3168
3169
3170 // A wxLog class that can be derived from in wxPython
3171 class wxPyLog : public wxLog {
3172 public:
3173 wxPyLog() : wxLog() {}
3174
3175 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3176 bool found;
3177 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3178 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3179 PyObject* s = wx2PyString(szString);
3180 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3181 Py_DECREF(s);
3182 }
3183 wxPyEndBlockThreads(blocked);
3184 if (! found)
3185 wxLog::DoLog(level, szString, t);
3186 }
3187
3188 virtual void DoLogString(const wxChar *szString, time_t t) {
3189 bool found;
3190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3191 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3192 PyObject* s = wx2PyString(szString);
3193 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3194 Py_DECREF(s);
3195 }
3196 wxPyEndBlockThreads(blocked);
3197 if (! found)
3198 wxLog::DoLogString(szString, t);
3199 }
3200
3201 DEC_PYCALLBACK_VOID_(Flush);
3202 PYPRIVATE;
3203 };
3204 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3205
3206
3207
3208
3209 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3210
3211
3212 #include <wx/joystick.h>
3213
3214
3215 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3216 // A C++ stub class for wxJoystick for platforms that don't have it.
3217 class wxJoystick : public wxObject {
3218 public:
3219 wxJoystick(int joystick = wxJOYSTICK1) {
3220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3221 PyErr_SetString(PyExc_NotImplementedError,
3222 "wxJoystick is not available on this platform.");
3223 wxPyEndBlockThreads(blocked);
3224 }
3225 wxPoint GetPosition() { return wxPoint(-1,-1); }
3226 int GetZPosition() { return -1; }
3227 int GetButtonState() { return -1; }
3228 int GetPOVPosition() { return -1; }
3229 int GetPOVCTSPosition() { return -1; }
3230 int GetRudderPosition() { return -1; }
3231 int GetUPosition() { return -1; }
3232 int GetVPosition() { return -1; }
3233 int GetMovementThreshold() { return -1; }
3234 void SetMovementThreshold(int threshold) {}
3235
3236 bool IsOk(void) { return false; }
3237 int GetNumberJoysticks() { return -1; }
3238 int GetManufacturerId() { return -1; }
3239 int GetProductId() { return -1; }
3240 wxString GetProductName() { return wxEmptyString; }
3241 int GetXMin() { return -1; }
3242 int GetYMin() { return -1; }
3243 int GetZMin() { return -1; }
3244 int GetXMax() { return -1; }
3245 int GetYMax() { return -1; }
3246 int GetZMax() { return -1; }
3247 int GetNumberButtons() { return -1; }
3248 int GetNumberAxes() { return -1; }
3249 int GetMaxButtons() { return -1; }
3250 int GetMaxAxes() { return -1; }
3251 int GetPollingMin() { return -1; }
3252 int GetPollingMax() { return -1; }
3253 int GetRudderMin() { return -1; }
3254 int GetRudderMax() { return -1; }
3255 int GetUMin() { return -1; }
3256 int GetUMax() { return -1; }
3257 int GetVMin() { return -1; }
3258 int GetVMax() { return -1; }
3259
3260 bool HasRudder() { return false; }
3261 bool HasZ() { return false; }
3262 bool HasU() { return false; }
3263 bool HasV() { return false; }
3264 bool HasPOV() { return false; }
3265 bool HasPOV4Dir() { return false; }
3266 bool HasPOVCTS() { return false; }
3267
3268 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3269 bool ReleaseCapture() { return false; }
3270 };
3271 #endif
3272
3273
3274 #include <wx/sound.h>
3275
3276
3277 #if !wxUSE_SOUND
3278 // A C++ stub class for wxWave for platforms that don't have it.
3279 class wxSound : public wxObject
3280 {
3281 public:
3282 wxSound() {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288 wxSound(const wxString&/*, bool*/) {
3289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3290 PyErr_SetString(PyExc_NotImplementedError,
3291 "wxSound is not available on this platform.");
3292 wxPyEndBlockThreads(blocked);
3293 }
3294 wxSound(int, const wxByte*) {
3295 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3296 PyErr_SetString(PyExc_NotImplementedError,
3297 "wxSound is not available on this platform.");
3298 wxPyEndBlockThreads(blocked);
3299 }
3300
3301 ~wxSound() {};
3302
3303 bool Create(const wxString&/*, bool*/) { return false; }
3304 bool Create(int, const wxByte*) { return false; };
3305 bool IsOk() { return false; };
3306 bool Play(unsigned) const { return false; }
3307 static bool Play(const wxString&, unsigned) { return false; }
3308 static void Stop() {}
3309 };
3310
3311 #endif
3312
3313 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3314 if (fileName.Length() == 0)
3315 return new wxSound;
3316 else
3317 return new wxSound(fileName);
3318 }
3319 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3320 unsigned char* buffer; int size;
3321 wxSound *sound = NULL;
3322
3323 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3324 if (!PyArg_Parse(data, "t#", &buffer, &size))
3325 goto done;
3326 sound = new wxSound(size, buffer);
3327 done:
3328 wxPyEndBlockThreads(blocked);
3329 return sound;
3330 }
3331 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3332 #ifndef __WXMAC__
3333 unsigned char* buffer;
3334 int size;
3335 bool rv = false;
3336
3337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3338 if (!PyArg_Parse(data, "t#", &buffer, &size))
3339 goto done;
3340 rv = self->Create(size, buffer);
3341 done:
3342 wxPyEndBlockThreads(blocked);
3343 return rv;
3344 #else
3345 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3346 PyErr_SetString(PyExc_NotImplementedError,
3347 "Create from data is not available on this platform.");
3348 wxPyEndBlockThreads(blocked);
3349 return false;
3350 #endif
3351 }
3352
3353 #include <wx/mimetype.h>
3354
3355 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3356 wxString str;
3357 if (self->GetMimeType(&str))
3358 return wx2PyString(str);
3359 else
3360 RETURN_NONE();
3361 }
3362 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3363 wxArrayString arr;
3364 if (self->GetMimeTypes(arr))
3365 return wxArrayString2PyList_helper(arr);
3366 else
3367 RETURN_NONE();
3368 }
3369 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3370 wxArrayString arr;
3371 if (self->GetExtensions(arr))
3372 return wxArrayString2PyList_helper(arr);
3373 else
3374 RETURN_NONE();
3375 }
3376 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3377 wxIconLocation loc;
3378 if (self->GetIcon(&loc))
3379 return new wxIcon(loc);
3380 else
3381 return NULL;
3382 }
3383 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3384 wxIconLocation loc;
3385 if (self->GetIcon(&loc)) {
3386 wxString iconFile = loc.GetFileName();
3387 int iconIndex = -1;
3388
3389
3390
3391 // Make a tuple and put the values in it
3392 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3393 PyObject* tuple = PyTuple_New(3);
3394 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3395 wxT("wxIcon"), true));
3396 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3397 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3398 wxPyEndBlockThreads(blocked);
3399 return tuple;
3400 }
3401 else
3402 RETURN_NONE();
3403 }
3404 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3405 wxString str;
3406 if (self->GetDescription(&str))
3407 return wx2PyString(str);
3408 else
3409 RETURN_NONE();
3410 }
3411 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3412 wxString str;
3413 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3414 return wx2PyString(str);
3415 else
3416 RETURN_NONE();
3417 }
3418 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3419 wxString str;
3420 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3421 return wx2PyString(str);
3422 else
3423 RETURN_NONE();
3424 }
3425 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3426 wxArrayString verbs;
3427 wxArrayString commands;
3428 if (self->GetAllCommands(&verbs, &commands,
3429 wxFileType::MessageParameters(filename, mimetype))) {
3430 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3431 PyObject* tuple = PyTuple_New(2);
3432 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3433 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3434 wxPyEndBlockThreads(blocked);
3435 return tuple;
3436 }
3437 else
3438 RETURN_NONE();
3439 }
3440 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3441 return wxFileType::ExpandCommand(command,
3442 wxFileType::MessageParameters(filename, mimetype));
3443 }
3444 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3445 wxArrayString arr;
3446 self->EnumAllFileTypes(arr);
3447 return wxArrayString2PyList_helper(arr);
3448 }
3449
3450 #include <wx/artprov.h>
3451
3452 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3453 static const wxString wxPyART_MENU(wxART_MENU);
3454 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3455 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3456 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3457 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3458 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3459 static const wxString wxPyART_OTHER(wxART_OTHER);
3460 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3461 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3462 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3463 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3464 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3465 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3466 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3467 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3468 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3469 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3470 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3471 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3472 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3473 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3474 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3475 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3476 static const wxString wxPyART_PRINT(wxART_PRINT);
3477 static const wxString wxPyART_HELP(wxART_HELP);
3478 static const wxString wxPyART_TIP(wxART_TIP);
3479 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3480 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3481 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3482 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3483 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3484 static const wxString wxPyART_CDROM(wxART_CDROM);
3485 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3486 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3487 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3488 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3489 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3490 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3491 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3492 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3493 static const wxString wxPyART_ERROR(wxART_ERROR);
3494 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3495 static const wxString wxPyART_WARNING(wxART_WARNING);
3496 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3497 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3498 static const wxString wxPyART_COPY(wxART_COPY);
3499 static const wxString wxPyART_CUT(wxART_CUT);
3500 static const wxString wxPyART_PASTE(wxART_PASTE);
3501 static const wxString wxPyART_DELETE(wxART_DELETE);
3502 static const wxString wxPyART_NEW(wxART_NEW);
3503 static const wxString wxPyART_UNDO(wxART_UNDO);
3504 static const wxString wxPyART_REDO(wxART_REDO);
3505 static const wxString wxPyART_QUIT(wxART_QUIT);
3506 static const wxString wxPyART_FIND(wxART_FIND);
3507 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3508 // Python aware wxArtProvider
3509 class wxPyArtProvider : public wxArtProvider {
3510 public:
3511
3512 virtual wxBitmap CreateBitmap(const wxArtID& id,
3513 const wxArtClient& client,
3514 const wxSize& size) {
3515 wxBitmap rval = wxNullBitmap;
3516 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3517 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3518 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3519 PyObject* ro;
3520 wxBitmap* ptr;
3521 PyObject* s1, *s2;
3522 s1 = wx2PyString(id);
3523 s2 = wx2PyString(client);
3524 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3525 Py_DECREF(so);
3526 Py_DECREF(s1);
3527 Py_DECREF(s2);
3528 if (ro) {
3529 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3530 rval = *ptr;
3531 Py_DECREF(ro);
3532 }
3533 }
3534 wxPyEndBlockThreads(blocked);
3535 return rval;
3536 }
3537
3538 PYPRIVATE;
3539 };
3540
3541 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3542
3543
3544
3545 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3546 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3547 PyObject* ret = PyTuple_New(3);
3548 if (ret) {
3549 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3550 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3551 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3552 }
3553 wxPyEndBlockThreads(blocked);
3554 return ret;
3555 }
3556
3557 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3558 bool cont;
3559 long index = 0;
3560 wxString value;
3561
3562 cont = self->GetFirstGroup(value, index);
3563 return __EnumerationHelper(cont, value, index);
3564 }
3565 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3566 bool cont;
3567 wxString value;
3568
3569 cont = self->GetNextGroup(value, index);
3570 return __EnumerationHelper(cont, value, index);
3571 }
3572 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3573 bool cont;
3574 long index = 0;
3575 wxString value;
3576
3577 cont = self->GetFirstEntry(value, index);
3578 return __EnumerationHelper(cont, value, index);
3579 }
3580 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3581 bool cont;
3582 wxString value;
3583
3584 cont = self->GetNextEntry(value, index);
3585 return __EnumerationHelper(cont, value, index);
3586 }
3587 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3588 long rv;
3589 self->Read(key, &rv, defaultVal);
3590 return rv;
3591 }
3592
3593 SWIGINTERN int
3594 SWIG_AsVal_double (PyObject *obj, double* val)
3595 {
3596 if (PyNumber_Check(obj)) {
3597 if (val) *val = PyFloat_AsDouble(obj);
3598 return SWIG_OK;
3599 }
3600 return SWIG_TypeError;
3601 }
3602
3603 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3604 double rv;
3605 self->Read(key, &rv, defaultVal);
3606 return rv;
3607 }
3608
3609 #define SWIG_From_double PyFloat_FromDouble
3610
3611 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3612 bool rv;
3613 self->Read(key, &rv, defaultVal);
3614 return rv;
3615 }
3616
3617 #include <wx/datetime.h>
3618
3619 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3620 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3621
3622 #define LOCAL_TZ wxDateTime::Local
3623
3624 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3625 wxString am;
3626 wxString pm;
3627 wxDateTime::GetAmPmStrings(&am, &pm);
3628 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3629 PyObject* tup = PyTuple_New(2);
3630 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3631 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3632 wxPyEndBlockThreads(blocked);
3633 return tup;
3634 }
3635
3636 SWIGINTERNINLINE PyObject *
3637 SWIG_From_unsigned_SS_int (unsigned int value)
3638 {
3639 return SWIG_From_unsigned_SS_long (value);
3640 }
3641
3642 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3643 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3644 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3645 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3646 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3647 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3648 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3649 return (*self < *other);
3650 }
3651 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3652 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3653 return (*self <= *other);
3654 }
3655 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3656 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3657 return (*self > *other);
3658 }
3659 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3660 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3661 return (*self >= *other);
3662 }
3663 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3664 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3665 return (*self == *other);
3666 }
3667 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3668 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3669 return (*self != *other);
3670 }
3671 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3672 const wxChar* rv;
3673 const wxChar* _date = date;
3674 rv = self->ParseRfc822Date(_date);
3675 if (rv == NULL) return -1;
3676 return rv - _date;
3677 }
3678 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3679 const wxChar* rv;
3680 const wxChar* _date = date;
3681 rv = self->ParseFormat(_date, format, dateDef);
3682 if (rv == NULL) return -1;
3683 return rv - _date;
3684 }
3685 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3686 const wxChar* rv;
3687 const wxChar* _datetime = datetime;
3688 rv = self->ParseDateTime(_datetime);
3689 if (rv == NULL) return -1;
3690 return rv - _datetime;
3691 }
3692 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3693 const wxChar* rv;
3694 const wxChar* _date = date;
3695 rv = self->ParseDate(_date);
3696 if (rv == NULL) return -1;
3697 return rv - _date;
3698 }
3699 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3700 const wxChar* rv;
3701 const wxChar* _time = time;
3702 rv = self->ParseTime(_time);
3703 if (rv == NULL) return -1;
3704 return rv - _time;
3705 }
3706 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3707 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3708 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3709 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3710 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3711 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3712 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3713 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3714 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3715 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3716 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3717 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3718 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3719 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3720 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3721 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3722
3723 #include <wx/dataobj.h>
3724
3725 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3726 size_t count = self->GetFormatCount(dir);
3727 wxDataFormat* formats = new wxDataFormat[count];
3728 self->GetAllFormats(formats, dir);
3729
3730 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3731 PyObject* list = PyList_New(count);
3732 for (size_t i=0; i<count; i++) {
3733 wxDataFormat* format = new wxDataFormat(formats[i]);
3734 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3735 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3736 }
3737 wxPyEndBlockThreads(blocked);
3738 delete [] formats;
3739 return list;
3740 }
3741 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3742 PyObject* rval = NULL;
3743 size_t size = self->GetDataSize(format);
3744 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3745 if (size) {
3746 char* buf = new char[size];
3747 if (self->GetDataHere(format, buf))
3748 rval = PyString_FromStringAndSize(buf, size);
3749 delete [] buf;
3750 }
3751 if (! rval) {
3752 rval = Py_None;
3753 Py_INCREF(rval);
3754 }
3755 wxPyEndBlockThreads(blocked);
3756 return rval;
3757 }
3758 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3759 bool rval;
3760 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3761 if (PyString_Check(data)) {
3762 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3763 }
3764 else {
3765 // raise a TypeError if not a string
3766 PyErr_SetString(PyExc_TypeError, "String expected.");
3767 rval = false;
3768 }
3769 wxPyEndBlockThreads(blocked);
3770 return rval;
3771 }
3772 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3773 PyObject* rval = NULL;
3774 size_t size = self->GetDataSize();
3775 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3776 if (size) {
3777 char* buf = new char[size];
3778 if (self->GetDataHere(buf))
3779 rval = PyString_FromStringAndSize(buf, size);
3780 delete [] buf;
3781 }
3782 if (! rval) {
3783 rval = Py_None;
3784 Py_INCREF(rval);
3785 }
3786 wxPyEndBlockThreads(blocked);
3787 return rval;
3788 }
3789 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3790 bool rval;
3791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3792 if (PyString_Check(data)) {
3793 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3794 }
3795 else {
3796 // raise a TypeError if not a string
3797 PyErr_SetString(PyExc_TypeError, "String expected.");
3798 rval = false;
3799 }
3800 wxPyEndBlockThreads(blocked);
3801 return rval;
3802 }
3803 // Create a new class for wxPython to use
3804 class wxPyDataObjectSimple : public wxDataObjectSimple {
3805 public:
3806 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3807 : wxDataObjectSimple(format) {}
3808
3809 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3810 bool GetDataHere(void *buf) const;
3811 bool SetData(size_t len, const void *buf);
3812 PYPRIVATE;
3813 };
3814
3815 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3816
3817 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3818 // We need to get the data for this object and write it to buf. I think
3819 // the best way to do this for wxPython is to have the Python method
3820 // return either a string or None and then act appropriately with the
3821 // C++ version.
3822
3823 bool rval = false;
3824 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3825 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3826 PyObject* ro;
3827 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3828 if (ro) {
3829 rval = (ro != Py_None && PyString_Check(ro));
3830 if (rval)
3831 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3832 Py_DECREF(ro);
3833 }
3834 }
3835 wxPyEndBlockThreads(blocked);
3836 return rval;
3837 }
3838
3839 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) {
3840 // For this one we simply need to make a string from buf and len
3841 // and send it to the Python method.
3842 bool rval = false;
3843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3844 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3845 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3846 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3847 Py_DECREF(data);
3848 }
3849 wxPyEndBlockThreads(blocked);
3850 return rval;
3851 }
3852
3853 // Create a new class for wxPython to use
3854 class wxPyTextDataObject : public wxTextDataObject {
3855 public:
3856 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3857 : wxTextDataObject(text) {}
3858
3859 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3860 DEC_PYCALLBACK_STRING__const(GetText);
3861 DEC_PYCALLBACK__STRING(SetText);
3862 PYPRIVATE;
3863 };
3864
3865 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3866 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3867 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3868
3869
3870 // Create a new class for wxPython to use
3871 class wxPyBitmapDataObject : public wxBitmapDataObject {
3872 public:
3873 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3874 : wxBitmapDataObject(bitmap) {}
3875
3876 wxBitmap GetBitmap() const;
3877 void SetBitmap(const wxBitmap& bitmap);
3878 PYPRIVATE;
3879 };
3880
3881 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3882 wxBitmap* rval = &wxNullBitmap;
3883 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3884 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3885 PyObject* ro;
3886 wxBitmap* ptr;
3887 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3888 if (ro) {
3889 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3890 rval = ptr;
3891 Py_DECREF(ro);
3892 }
3893 }
3894 wxPyEndBlockThreads(blocked);
3895 return *rval;
3896 }
3897
3898 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3899 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3900 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3901 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3902 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3903 Py_DECREF(bo);
3904 }
3905 wxPyEndBlockThreads(blocked);
3906 }
3907
3908 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3909 return new wxCustomDataObject(wxDataFormat(formatName));
3910 }
3911 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3912 bool rval;
3913 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3914 if (PyString_Check(data)) {
3915 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3916 }
3917 else {
3918 // raise a TypeError if not a string
3919 PyErr_SetString(PyExc_TypeError, "String expected.");
3920 rval = false;
3921 }
3922 wxPyEndBlockThreads(blocked);
3923 return rval;
3924 }
3925 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3926 PyObject* obj;
3927 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3928 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3929 wxPyEndBlockThreads(blocked);
3930 return obj;
3931 }
3932
3933 class wxMetafileDataObject : public wxDataObjectSimple
3934 {
3935 public:
3936 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
3937 };
3938
3939
3940 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3941
3942
3943 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3944 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3945 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3946 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3947 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3948
3949
3950 class wxPyTextDropTarget : public wxTextDropTarget {
3951 public:
3952 wxPyTextDropTarget() {}
3953
3954 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3955
3956 DEC_PYCALLBACK__(OnLeave);
3957 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3958 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3959 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3960 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3961
3962 PYPRIVATE;
3963 };
3964
3965 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3966 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3967 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3968 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3969 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3970 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3971
3972
3973
3974 class wxPyFileDropTarget : public wxFileDropTarget {
3975 public:
3976 wxPyFileDropTarget() {}
3977
3978 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3979
3980 DEC_PYCALLBACK__(OnLeave);
3981 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3982 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3983 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3984 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3985
3986 PYPRIVATE;
3987 };
3988
3989 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3990 const wxArrayString& filenames) {
3991 bool rval = false;
3992 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3993 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3994 PyObject* list = wxArrayString2PyList_helper(filenames);
3995 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3996 Py_DECREF(list);
3997 }
3998 wxPyEndBlockThreads(blocked);
3999 return rval;
4000 }
4001
4002
4003
4004 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
4005 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
4006 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
4007 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
4008 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
4009
4010
4011
4012
4013 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
4014
4015 #include <wx/display.h>
4016
4017 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4018 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4019
4020 #if !wxUSE_DISPLAY
4021 const wxVideoMode wxDefaultVideoMode;
4022 #endif
4023
4024 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4025 #if wxUSE_DISPLAY
4026 PyObject* pyList = NULL;
4027 wxArrayVideoModes arr = self->GetModes(mode);
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 pyList = PyList_New(0);
4030 for (size_t i=0; i < arr.GetCount(); i++)
4031 {
4032 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4033 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4034 PyList_Append(pyList, pyObj);
4035 Py_DECREF(pyObj);
4036 }
4037 wxPyEndBlockThreads(blocked);
4038 return pyList;
4039 #else
4040 wxPyRaiseNotImplemented();
4041 return NULL;
4042 #endif
4043 }
4044 SWIGINTERN wxVideoMode wxDisplay_GetCurrentMode(wxDisplay const *self){
4045 #if wxUSE_DISPLAY
4046 return self->GetCurrentMode();
4047 #else
4048 wxPyRaiseNotImplemented();
4049 return wxDefaultVideoMode;
4050 #endif
4051 }
4052 SWIGINTERN bool wxDisplay_ChangeMode(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4053 #if wxUSE_DISPLAY
4054 return self->ChangeMode(mode);
4055 #else
4056 wxPyRaiseNotImplemented();
4057 return false;
4058 #endif
4059 }
4060 SWIGINTERN void wxDisplay_ResetMode(wxDisplay *self){
4061 #if wxUSE_DISPLAY
4062 self->ResetMode();
4063 #else
4064 wxPyRaiseNotImplemented();
4065 #endif
4066 }
4067
4068 #include <wx/stdpaths.h>
4069
4070 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4071 return (wxStandardPaths*) &wxStandardPaths::Get();
4072 }
4073
4074 #ifndef wxHAS_POWER_EVENTS
4075 // Dummy class and other definitions for platforms that don't have them
4076
4077 // See wxPython_int.h for wxPowerEvent
4078
4079 enum {
4080 wxEVT_POWER_SUSPENDING,
4081 wxEVT_POWER_SUSPENDED,
4082 wxEVT_POWER_SUSPEND_CANCEL,
4083 wxEVT_POWER_RESUME,
4084 };
4085
4086 wxPowerType wxGetPowerType() { return wxPOWER_UNKNOWN; }
4087 wxBatteryState wxGetBatteryState() { return wxBATTERY_UNKNOWN_STATE; }
4088
4089 #endif
4090
4091 #ifdef __cplusplus
4092 extern "C" {
4093 #endif
4094 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4095 PyObject *resultobj = 0;
4096 wxSystemColour arg1 ;
4097 wxColour result;
4098 int val1 ;
4099 int ecode1 = 0 ;
4100 PyObject * obj0 = 0 ;
4101 char * kwnames[] = {
4102 (char *) "index", NULL
4103 };
4104
4105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4106 ecode1 = SWIG_AsVal_int(obj0, &val1);
4107 if (!SWIG_IsOK(ecode1)) {
4108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4109 }
4110 arg1 = static_cast< wxSystemColour >(val1);
4111 {
4112 if (!wxPyCheckForApp()) SWIG_fail;
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 result = wxSystemSettings::GetColour(arg1);
4115 wxPyEndAllowThreads(__tstate);
4116 if (PyErr_Occurred()) SWIG_fail;
4117 }
4118 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4119 return resultobj;
4120 fail:
4121 return NULL;
4122 }
4123
4124
4125 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4126 PyObject *resultobj = 0;
4127 wxSystemFont arg1 ;
4128 wxFont result;
4129 int val1 ;
4130 int ecode1 = 0 ;
4131 PyObject * obj0 = 0 ;
4132 char * kwnames[] = {
4133 (char *) "index", NULL
4134 };
4135
4136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4137 ecode1 = SWIG_AsVal_int(obj0, &val1);
4138 if (!SWIG_IsOK(ecode1)) {
4139 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4140 }
4141 arg1 = static_cast< wxSystemFont >(val1);
4142 {
4143 if (!wxPyCheckForApp()) SWIG_fail;
4144 PyThreadState* __tstate = wxPyBeginAllowThreads();
4145 result = wxSystemSettings::GetFont(arg1);
4146 wxPyEndAllowThreads(__tstate);
4147 if (PyErr_Occurred()) SWIG_fail;
4148 }
4149 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4150 return resultobj;
4151 fail:
4152 return NULL;
4153 }
4154
4155
4156 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4157 PyObject *resultobj = 0;
4158 wxSystemMetric arg1 ;
4159 wxWindow *arg2 = (wxWindow *) NULL ;
4160 int result;
4161 int val1 ;
4162 int ecode1 = 0 ;
4163 void *argp2 = 0 ;
4164 int res2 = 0 ;
4165 PyObject * obj0 = 0 ;
4166 PyObject * obj1 = 0 ;
4167 char * kwnames[] = {
4168 (char *) "index",(char *) "win", NULL
4169 };
4170
4171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4172 ecode1 = SWIG_AsVal_int(obj0, &val1);
4173 if (!SWIG_IsOK(ecode1)) {
4174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4175 }
4176 arg1 = static_cast< wxSystemMetric >(val1);
4177 if (obj1) {
4178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4179 if (!SWIG_IsOK(res2)) {
4180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4181 }
4182 arg2 = reinterpret_cast< wxWindow * >(argp2);
4183 }
4184 {
4185 if (!wxPyCheckForApp()) SWIG_fail;
4186 PyThreadState* __tstate = wxPyBeginAllowThreads();
4187 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4188 wxPyEndAllowThreads(__tstate);
4189 if (PyErr_Occurred()) SWIG_fail;
4190 }
4191 resultobj = SWIG_From_int(static_cast< int >(result));
4192 return resultobj;
4193 fail:
4194 return NULL;
4195 }
4196
4197
4198 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4199 PyObject *resultobj = 0;
4200 wxSystemFeature arg1 ;
4201 bool result;
4202 int val1 ;
4203 int ecode1 = 0 ;
4204 PyObject * obj0 = 0 ;
4205 char * kwnames[] = {
4206 (char *) "index", NULL
4207 };
4208
4209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4210 ecode1 = SWIG_AsVal_int(obj0, &val1);
4211 if (!SWIG_IsOK(ecode1)) {
4212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4213 }
4214 arg1 = static_cast< wxSystemFeature >(val1);
4215 {
4216 if (!wxPyCheckForApp()) SWIG_fail;
4217 PyThreadState* __tstate = wxPyBeginAllowThreads();
4218 result = (bool)wxSystemSettings::HasFeature(arg1);
4219 wxPyEndAllowThreads(__tstate);
4220 if (PyErr_Occurred()) SWIG_fail;
4221 }
4222 {
4223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4224 }
4225 return resultobj;
4226 fail:
4227 return NULL;
4228 }
4229
4230
4231 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4232 PyObject *resultobj = 0;
4233 wxSystemScreenType result;
4234
4235 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4236 {
4237 if (!wxPyCheckForApp()) SWIG_fail;
4238 PyThreadState* __tstate = wxPyBeginAllowThreads();
4239 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4240 wxPyEndAllowThreads(__tstate);
4241 if (PyErr_Occurred()) SWIG_fail;
4242 }
4243 resultobj = SWIG_From_int(static_cast< int >(result));
4244 return resultobj;
4245 fail:
4246 return NULL;
4247 }
4248
4249
4250 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4251 PyObject *resultobj = 0;
4252 wxSystemScreenType arg1 ;
4253 int val1 ;
4254 int ecode1 = 0 ;
4255 PyObject * obj0 = 0 ;
4256 char * kwnames[] = {
4257 (char *) "screen", NULL
4258 };
4259
4260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4261 ecode1 = SWIG_AsVal_int(obj0, &val1);
4262 if (!SWIG_IsOK(ecode1)) {
4263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4264 }
4265 arg1 = static_cast< wxSystemScreenType >(val1);
4266 {
4267 if (!wxPyCheckForApp()) SWIG_fail;
4268 PyThreadState* __tstate = wxPyBeginAllowThreads();
4269 wxSystemSettings::SetScreenType(arg1);
4270 wxPyEndAllowThreads(__tstate);
4271 if (PyErr_Occurred()) SWIG_fail;
4272 }
4273 resultobj = SWIG_Py_Void();
4274 return resultobj;
4275 fail:
4276 return NULL;
4277 }
4278
4279
4280 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4281 PyObject *obj;
4282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4283 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4284 return SWIG_Py_Void();
4285 }
4286
4287 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4288 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4289 return 1;
4290 }
4291
4292
4293 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4294 PyObject *pyobj = 0;
4295
4296 {
4297 #if wxUSE_UNICODE
4298 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4299 #else
4300 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4301 #endif
4302 }
4303 return pyobj;
4304 }
4305
4306
4307 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4308 PyObject *resultobj = 0;
4309 wxSystemOptions *result = 0 ;
4310
4311 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4312 {
4313 PyThreadState* __tstate = wxPyBeginAllowThreads();
4314 result = (wxSystemOptions *)new wxSystemOptions();
4315 wxPyEndAllowThreads(__tstate);
4316 if (PyErr_Occurred()) SWIG_fail;
4317 }
4318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4319 return resultobj;
4320 fail:
4321 return NULL;
4322 }
4323
4324
4325 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4326 PyObject *resultobj = 0;
4327 wxString *arg1 = 0 ;
4328 wxString *arg2 = 0 ;
4329 bool temp1 = false ;
4330 bool temp2 = false ;
4331 PyObject * obj0 = 0 ;
4332 PyObject * obj1 = 0 ;
4333 char * kwnames[] = {
4334 (char *) "name",(char *) "value", NULL
4335 };
4336
4337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4338 {
4339 arg1 = wxString_in_helper(obj0);
4340 if (arg1 == NULL) SWIG_fail;
4341 temp1 = true;
4342 }
4343 {
4344 arg2 = wxString_in_helper(obj1);
4345 if (arg2 == NULL) SWIG_fail;
4346 temp2 = true;
4347 }
4348 {
4349 PyThreadState* __tstate = wxPyBeginAllowThreads();
4350 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4351 wxPyEndAllowThreads(__tstate);
4352 if (PyErr_Occurred()) SWIG_fail;
4353 }
4354 resultobj = SWIG_Py_Void();
4355 {
4356 if (temp1)
4357 delete arg1;
4358 }
4359 {
4360 if (temp2)
4361 delete arg2;
4362 }
4363 return resultobj;
4364 fail:
4365 {
4366 if (temp1)
4367 delete arg1;
4368 }
4369 {
4370 if (temp2)
4371 delete arg2;
4372 }
4373 return NULL;
4374 }
4375
4376
4377 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4378 PyObject *resultobj = 0;
4379 wxString *arg1 = 0 ;
4380 int arg2 ;
4381 bool temp1 = false ;
4382 int val2 ;
4383 int ecode2 = 0 ;
4384 PyObject * obj0 = 0 ;
4385 PyObject * obj1 = 0 ;
4386 char * kwnames[] = {
4387 (char *) "name",(char *) "value", NULL
4388 };
4389
4390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4391 {
4392 arg1 = wxString_in_helper(obj0);
4393 if (arg1 == NULL) SWIG_fail;
4394 temp1 = true;
4395 }
4396 ecode2 = SWIG_AsVal_int(obj1, &val2);
4397 if (!SWIG_IsOK(ecode2)) {
4398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4399 }
4400 arg2 = static_cast< int >(val2);
4401 {
4402 PyThreadState* __tstate = wxPyBeginAllowThreads();
4403 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4404 wxPyEndAllowThreads(__tstate);
4405 if (PyErr_Occurred()) SWIG_fail;
4406 }
4407 resultobj = SWIG_Py_Void();
4408 {
4409 if (temp1)
4410 delete arg1;
4411 }
4412 return resultobj;
4413 fail:
4414 {
4415 if (temp1)
4416 delete arg1;
4417 }
4418 return NULL;
4419 }
4420
4421
4422 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4423 PyObject *resultobj = 0;
4424 wxString *arg1 = 0 ;
4425 wxString result;
4426 bool temp1 = false ;
4427 PyObject * obj0 = 0 ;
4428 char * kwnames[] = {
4429 (char *) "name", NULL
4430 };
4431
4432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4433 {
4434 arg1 = wxString_in_helper(obj0);
4435 if (arg1 == NULL) SWIG_fail;
4436 temp1 = true;
4437 }
4438 {
4439 PyThreadState* __tstate = wxPyBeginAllowThreads();
4440 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4441 wxPyEndAllowThreads(__tstate);
4442 if (PyErr_Occurred()) SWIG_fail;
4443 }
4444 {
4445 #if wxUSE_UNICODE
4446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4447 #else
4448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4449 #endif
4450 }
4451 {
4452 if (temp1)
4453 delete arg1;
4454 }
4455 return resultobj;
4456 fail:
4457 {
4458 if (temp1)
4459 delete arg1;
4460 }
4461 return NULL;
4462 }
4463
4464
4465 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4466 PyObject *resultobj = 0;
4467 wxString *arg1 = 0 ;
4468 int result;
4469 bool temp1 = false ;
4470 PyObject * obj0 = 0 ;
4471 char * kwnames[] = {
4472 (char *) "name", NULL
4473 };
4474
4475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4476 {
4477 arg1 = wxString_in_helper(obj0);
4478 if (arg1 == NULL) SWIG_fail;
4479 temp1 = true;
4480 }
4481 {
4482 PyThreadState* __tstate = wxPyBeginAllowThreads();
4483 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4484 wxPyEndAllowThreads(__tstate);
4485 if (PyErr_Occurred()) SWIG_fail;
4486 }
4487 resultobj = SWIG_From_int(static_cast< int >(result));
4488 {
4489 if (temp1)
4490 delete arg1;
4491 }
4492 return resultobj;
4493 fail:
4494 {
4495 if (temp1)
4496 delete arg1;
4497 }
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4503 PyObject *resultobj = 0;
4504 wxString *arg1 = 0 ;
4505 bool result;
4506 bool temp1 = false ;
4507 PyObject * obj0 = 0 ;
4508 char * kwnames[] = {
4509 (char *) "name", NULL
4510 };
4511
4512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4513 {
4514 arg1 = wxString_in_helper(obj0);
4515 if (arg1 == NULL) SWIG_fail;
4516 temp1 = true;
4517 }
4518 {
4519 PyThreadState* __tstate = wxPyBeginAllowThreads();
4520 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4521 wxPyEndAllowThreads(__tstate);
4522 if (PyErr_Occurred()) SWIG_fail;
4523 }
4524 {
4525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4526 }
4527 {
4528 if (temp1)
4529 delete arg1;
4530 }
4531 return resultobj;
4532 fail:
4533 {
4534 if (temp1)
4535 delete arg1;
4536 }
4537 return NULL;
4538 }
4539
4540
4541 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4542 PyObject *resultobj = 0;
4543 wxString *arg1 = 0 ;
4544 bool result;
4545 bool temp1 = false ;
4546 PyObject * obj0 = 0 ;
4547 char * kwnames[] = {
4548 (char *) "name", NULL
4549 };
4550
4551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4552 {
4553 arg1 = wxString_in_helper(obj0);
4554 if (arg1 == NULL) SWIG_fail;
4555 temp1 = true;
4556 }
4557 {
4558 PyThreadState* __tstate = wxPyBeginAllowThreads();
4559 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4560 wxPyEndAllowThreads(__tstate);
4561 if (PyErr_Occurred()) SWIG_fail;
4562 }
4563 {
4564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4565 }
4566 {
4567 if (temp1)
4568 delete arg1;
4569 }
4570 return resultobj;
4571 fail:
4572 {
4573 if (temp1)
4574 delete arg1;
4575 }
4576 return NULL;
4577 }
4578
4579
4580 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4581 PyObject *obj;
4582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4583 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4584 return SWIG_Py_Void();
4585 }
4586
4587 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4588 return SWIG_Python_InitShadowInstance(args);
4589 }
4590
4591 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4592 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4593 return 1;
4594 }
4595
4596
4597 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4598 PyObject *pyobj = 0;
4599
4600 {
4601 #if wxUSE_UNICODE
4602 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4603 #else
4604 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4605 #endif
4606 }
4607 return pyobj;
4608 }
4609
4610
4611 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4612 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4613 return 1;
4614 }
4615
4616
4617 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4618 PyObject *pyobj = 0;
4619
4620 {
4621 #if wxUSE_UNICODE
4622 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4623 #else
4624 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4625 #endif
4626 }
4627 return pyobj;
4628 }
4629
4630
4631 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4632 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4633 return 1;
4634 }
4635
4636
4637 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4638 PyObject *pyobj = 0;
4639
4640 {
4641 #if wxUSE_UNICODE
4642 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4643 #else
4644 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4645 #endif
4646 }
4647 return pyobj;
4648 }
4649
4650
4651 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4652 PyObject *resultobj = 0;
4653 long result;
4654
4655 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4656 {
4657 PyThreadState* __tstate = wxPyBeginAllowThreads();
4658 result = (long)wxNewId();
4659 wxPyEndAllowThreads(__tstate);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 resultobj = SWIG_From_long(static_cast< long >(result));
4663 return resultobj;
4664 fail:
4665 return NULL;
4666 }
4667
4668
4669 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4670 PyObject *resultobj = 0;
4671 long arg1 ;
4672 long val1 ;
4673 int ecode1 = 0 ;
4674 PyObject * obj0 = 0 ;
4675 char * kwnames[] = {
4676 (char *) "id", NULL
4677 };
4678
4679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4680 ecode1 = SWIG_AsVal_long(obj0, &val1);
4681 if (!SWIG_IsOK(ecode1)) {
4682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4683 }
4684 arg1 = static_cast< long >(val1);
4685 {
4686 PyThreadState* __tstate = wxPyBeginAllowThreads();
4687 wxRegisterId(arg1);
4688 wxPyEndAllowThreads(__tstate);
4689 if (PyErr_Occurred()) SWIG_fail;
4690 }
4691 resultobj = SWIG_Py_Void();
4692 return resultobj;
4693 fail:
4694 return NULL;
4695 }
4696
4697
4698 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4699 PyObject *resultobj = 0;
4700 long result;
4701
4702 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4703 {
4704 PyThreadState* __tstate = wxPyBeginAllowThreads();
4705 result = (long)wxGetCurrentId();
4706 wxPyEndAllowThreads(__tstate);
4707 if (PyErr_Occurred()) SWIG_fail;
4708 }
4709 resultobj = SWIG_From_long(static_cast< long >(result));
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4717 PyObject *resultobj = 0;
4718 int arg1 ;
4719 bool result;
4720 int val1 ;
4721 int ecode1 = 0 ;
4722 PyObject * obj0 = 0 ;
4723 char * kwnames[] = {
4724 (char *) "id", NULL
4725 };
4726
4727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4728 ecode1 = SWIG_AsVal_int(obj0, &val1);
4729 if (!SWIG_IsOK(ecode1)) {
4730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4731 }
4732 arg1 = static_cast< int >(val1);
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 result = (bool)wxIsStockID(arg1);
4736 wxPyEndAllowThreads(__tstate);
4737 if (PyErr_Occurred()) SWIG_fail;
4738 }
4739 {
4740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4741 }
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4749 PyObject *resultobj = 0;
4750 int arg1 ;
4751 wxString *arg2 = 0 ;
4752 bool result;
4753 int val1 ;
4754 int ecode1 = 0 ;
4755 bool temp2 = false ;
4756 PyObject * obj0 = 0 ;
4757 PyObject * obj1 = 0 ;
4758 char * kwnames[] = {
4759 (char *) "id",(char *) "label", NULL
4760 };
4761
4762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4763 ecode1 = SWIG_AsVal_int(obj0, &val1);
4764 if (!SWIG_IsOK(ecode1)) {
4765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4766 }
4767 arg1 = static_cast< int >(val1);
4768 {
4769 arg2 = wxString_in_helper(obj1);
4770 if (arg2 == NULL) SWIG_fail;
4771 temp2 = true;
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4776 wxPyEndAllowThreads(__tstate);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 {
4780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4781 }
4782 {
4783 if (temp2)
4784 delete arg2;
4785 }
4786 return resultobj;
4787 fail:
4788 {
4789 if (temp2)
4790 delete arg2;
4791 }
4792 return NULL;
4793 }
4794
4795
4796 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4797 PyObject *resultobj = 0;
4798 int arg1 ;
4799 bool arg2 = (bool) true ;
4800 wxString arg3 = (wxString) wxPyEmptyString ;
4801 wxString result;
4802 int val1 ;
4803 int ecode1 = 0 ;
4804 bool val2 ;
4805 int ecode2 = 0 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 PyObject * obj2 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4814 ecode1 = SWIG_AsVal_int(obj0, &val1);
4815 if (!SWIG_IsOK(ecode1)) {
4816 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4817 }
4818 arg1 = static_cast< int >(val1);
4819 if (obj1) {
4820 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4821 if (!SWIG_IsOK(ecode2)) {
4822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4823 }
4824 arg2 = static_cast< bool >(val2);
4825 }
4826 if (obj2) {
4827 {
4828 wxString* sptr = wxString_in_helper(obj2);
4829 if (sptr == NULL) SWIG_fail;
4830 arg3 = *sptr;
4831 delete sptr;
4832 }
4833 }
4834 {
4835 PyThreadState* __tstate = wxPyBeginAllowThreads();
4836 result = wxGetStockLabel(arg1,arg2,arg3);
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 {
4841 #if wxUSE_UNICODE
4842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4843 #else
4844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4845 #endif
4846 }
4847 return resultobj;
4848 fail:
4849 return NULL;
4850 }
4851
4852
4853 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4854 PyObject *resultobj = 0;
4855
4856 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4857 {
4858 if (!wxPyCheckForApp()) SWIG_fail;
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 wxBell();
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 resultobj = SWIG_Py_Void();
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4872 PyObject *resultobj = 0;
4873
4874 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4875 {
4876 if (!wxPyCheckForApp()) SWIG_fail;
4877 PyThreadState* __tstate = wxPyBeginAllowThreads();
4878 wxEndBusyCursor();
4879 wxPyEndAllowThreads(__tstate);
4880 if (PyErr_Occurred()) SWIG_fail;
4881 }
4882 resultobj = SWIG_Py_Void();
4883 return resultobj;
4884 fail:
4885 return NULL;
4886 }
4887
4888
4889 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4890 PyObject *resultobj = 0;
4891 bool arg1 = (bool) true ;
4892 long result;
4893 bool val1 ;
4894 int ecode1 = 0 ;
4895 PyObject * obj0 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "resetTimer", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4901 if (obj0) {
4902 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4903 if (!SWIG_IsOK(ecode1)) {
4904 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4905 }
4906 arg1 = static_cast< bool >(val1);
4907 }
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 result = (long)wxGetElapsedTime(arg1);
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_From_long(static_cast< long >(result));
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4922 PyObject *resultobj = 0;
4923 bool result;
4924
4925 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4926 {
4927 PyThreadState* __tstate = wxPyBeginAllowThreads();
4928 result = (bool)wxIsBusy();
4929 wxPyEndAllowThreads(__tstate);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 {
4933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4934 }
4935 return resultobj;
4936 fail:
4937 return NULL;
4938 }
4939
4940
4941 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4942 PyObject *resultobj = 0;
4943 wxString result;
4944
4945 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 result = wxNow();
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 {
4953 #if wxUSE_UNICODE
4954 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4955 #else
4956 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4957 #endif
4958 }
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj = 0;
4967 wxString const &arg1_defvalue = wxPyEmptyString ;
4968 wxString *arg1 = (wxString *) &arg1_defvalue ;
4969 bool result;
4970 bool temp1 = false ;
4971 PyObject * obj0 = 0 ;
4972 char * kwnames[] = {
4973 (char *) "command", NULL
4974 };
4975
4976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4977 if (obj0) {
4978 {
4979 arg1 = wxString_in_helper(obj0);
4980 if (arg1 == NULL) SWIG_fail;
4981 temp1 = true;
4982 }
4983 }
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 result = (bool)wxShell((wxString const &)*arg1);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 {
4991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4992 }
4993 {
4994 if (temp1)
4995 delete arg1;
4996 }
4997 return resultobj;
4998 fail:
4999 {
5000 if (temp1)
5001 delete arg1;
5002 }
5003 return NULL;
5004 }
5005
5006
5007 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5008 PyObject *resultobj = 0;
5009
5010 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 wxStartTimer();
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_Py_Void();
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 int *arg1 = (int *) 0 ;
5027 int *arg2 = (int *) 0 ;
5028 int result;
5029 int temp1 ;
5030 int res1 = SWIG_TMPOBJ ;
5031 int temp2 ;
5032 int res2 = SWIG_TMPOBJ ;
5033
5034 arg1 = &temp1;
5035 arg2 = &temp2;
5036 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5037 {
5038 PyThreadState* __tstate = wxPyBeginAllowThreads();
5039 result = (int)wxGetOsVersion(arg1,arg2);
5040 wxPyEndAllowThreads(__tstate);
5041 if (PyErr_Occurred()) SWIG_fail;
5042 }
5043 resultobj = SWIG_From_int(static_cast< int >(result));
5044 if (SWIG_IsTmpObj(res1)) {
5045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5046 } else {
5047 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5049 }
5050 if (SWIG_IsTmpObj(res2)) {
5051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5052 } else {
5053 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5054 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5055 }
5056 return resultobj;
5057 fail:
5058 return NULL;
5059 }
5060
5061
5062 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5063 PyObject *resultobj = 0;
5064 wxString result;
5065
5066 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = wxGetOsDescription();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 {
5074 #if wxUSE_UNICODE
5075 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5076 #else
5077 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5078 #endif
5079 }
5080 return resultobj;
5081 fail:
5082 return NULL;
5083 }
5084
5085
5086 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5087 PyObject *resultobj = 0;
5088 wxMemorySize result;
5089
5090 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = wxGetFreeMemory();
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 #if wxUSE_LONGLONG
5099 resultobj = PyLong_FromLongLong((&result)->GetValue());
5100 #else
5101 resultobj = PyInt_FromLong(result);
5102 #endif
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxShutdownFlags arg1 ;
5113 bool result;
5114 int val1 ;
5115 int ecode1 = 0 ;
5116 PyObject * obj0 = 0 ;
5117 char * kwnames[] = {
5118 (char *) "wFlags", NULL
5119 };
5120
5121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5122 ecode1 = SWIG_AsVal_int(obj0, &val1);
5123 if (!SWIG_IsOK(ecode1)) {
5124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5125 }
5126 arg1 = static_cast< wxShutdownFlags >(val1);
5127 {
5128 if (!wxPyCheckForApp()) SWIG_fail;
5129 PyThreadState* __tstate = wxPyBeginAllowThreads();
5130 result = (bool)wxShutdown(arg1);
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 {
5135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5136 }
5137 return resultobj;
5138 fail:
5139 return NULL;
5140 }
5141
5142
5143 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5144 PyObject *resultobj = 0;
5145 int arg1 ;
5146 int val1 ;
5147 int ecode1 = 0 ;
5148 PyObject * obj0 = 0 ;
5149 char * kwnames[] = {
5150 (char *) "secs", NULL
5151 };
5152
5153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5154 ecode1 = SWIG_AsVal_int(obj0, &val1);
5155 if (!SWIG_IsOK(ecode1)) {
5156 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5157 }
5158 arg1 = static_cast< int >(val1);
5159 {
5160 PyThreadState* __tstate = wxPyBeginAllowThreads();
5161 wxSleep(arg1);
5162 wxPyEndAllowThreads(__tstate);
5163 if (PyErr_Occurred()) SWIG_fail;
5164 }
5165 resultobj = SWIG_Py_Void();
5166 return resultobj;
5167 fail:
5168 return NULL;
5169 }
5170
5171
5172 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5173 PyObject *resultobj = 0;
5174 unsigned long arg1 ;
5175 unsigned long val1 ;
5176 int ecode1 = 0 ;
5177 PyObject * obj0 = 0 ;
5178 char * kwnames[] = {
5179 (char *) "milliseconds", NULL
5180 };
5181
5182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5183 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5184 if (!SWIG_IsOK(ecode1)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5186 }
5187 arg1 = static_cast< unsigned long >(val1);
5188 {
5189 PyThreadState* __tstate = wxPyBeginAllowThreads();
5190 wxMilliSleep(arg1);
5191 wxPyEndAllowThreads(__tstate);
5192 if (PyErr_Occurred()) SWIG_fail;
5193 }
5194 resultobj = SWIG_Py_Void();
5195 return resultobj;
5196 fail:
5197 return NULL;
5198 }
5199
5200
5201 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5202 PyObject *resultobj = 0;
5203 unsigned long arg1 ;
5204 unsigned long val1 ;
5205 int ecode1 = 0 ;
5206 PyObject * obj0 = 0 ;
5207 char * kwnames[] = {
5208 (char *) "microseconds", NULL
5209 };
5210
5211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5212 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5213 if (!SWIG_IsOK(ecode1)) {
5214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5215 }
5216 arg1 = static_cast< unsigned long >(val1);
5217 {
5218 PyThreadState* __tstate = wxPyBeginAllowThreads();
5219 wxMicroSleep(arg1);
5220 wxPyEndAllowThreads(__tstate);
5221 if (PyErr_Occurred()) SWIG_fail;
5222 }
5223 resultobj = SWIG_Py_Void();
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5231 PyObject *resultobj = 0;
5232 bool arg1 ;
5233 bool val1 ;
5234 int ecode1 = 0 ;
5235 PyObject * obj0 = 0 ;
5236 char * kwnames[] = {
5237 (char *) "enable", NULL
5238 };
5239
5240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5241 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5242 if (!SWIG_IsOK(ecode1)) {
5243 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5244 }
5245 arg1 = static_cast< bool >(val1);
5246 {
5247 PyThreadState* __tstate = wxPyBeginAllowThreads();
5248 wxEnableTopLevelWindows(arg1);
5249 wxPyEndAllowThreads(__tstate);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 resultobj = SWIG_Py_Void();
5253 return resultobj;
5254 fail:
5255 return NULL;
5256 }
5257
5258
5259 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5260 PyObject *resultobj = 0;
5261 wxString *arg1 = 0 ;
5262 wxString result;
5263 bool temp1 = false ;
5264 PyObject * obj0 = 0 ;
5265 char * kwnames[] = {
5266 (char *) "in", NULL
5267 };
5268
5269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5270 {
5271 arg1 = wxString_in_helper(obj0);
5272 if (arg1 == NULL) SWIG_fail;
5273 temp1 = true;
5274 }
5275 {
5276 PyThreadState* __tstate = wxPyBeginAllowThreads();
5277 result = wxStripMenuCodes((wxString const &)*arg1);
5278 wxPyEndAllowThreads(__tstate);
5279 if (PyErr_Occurred()) SWIG_fail;
5280 }
5281 {
5282 #if wxUSE_UNICODE
5283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5284 #else
5285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5286 #endif
5287 }
5288 {
5289 if (temp1)
5290 delete arg1;
5291 }
5292 return resultobj;
5293 fail:
5294 {
5295 if (temp1)
5296 delete arg1;
5297 }
5298 return NULL;
5299 }
5300
5301
5302 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5303 PyObject *resultobj = 0;
5304 wxString result;
5305
5306 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5307 {
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 result = wxGetEmailAddress();
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 {
5314 #if wxUSE_UNICODE
5315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5316 #else
5317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5318 #endif
5319 }
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5327 PyObject *resultobj = 0;
5328 wxString result;
5329
5330 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5331 {
5332 PyThreadState* __tstate = wxPyBeginAllowThreads();
5333 result = wxGetHostName();
5334 wxPyEndAllowThreads(__tstate);
5335 if (PyErr_Occurred()) SWIG_fail;
5336 }
5337 {
5338 #if wxUSE_UNICODE
5339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5340 #else
5341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5342 #endif
5343 }
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxString result;
5353
5354 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5355 {
5356 PyThreadState* __tstate = wxPyBeginAllowThreads();
5357 result = wxGetFullHostName();
5358 wxPyEndAllowThreads(__tstate);
5359 if (PyErr_Occurred()) SWIG_fail;
5360 }
5361 {
5362 #if wxUSE_UNICODE
5363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5364 #else
5365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5366 #endif
5367 }
5368 return resultobj;
5369 fail:
5370 return NULL;
5371 }
5372
5373
5374 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5375 PyObject *resultobj = 0;
5376 wxString result;
5377
5378 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5379 {
5380 PyThreadState* __tstate = wxPyBeginAllowThreads();
5381 result = wxGetUserId();
5382 wxPyEndAllowThreads(__tstate);
5383 if (PyErr_Occurred()) SWIG_fail;
5384 }
5385 {
5386 #if wxUSE_UNICODE
5387 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5388 #else
5389 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5390 #endif
5391 }
5392 return resultobj;
5393 fail:
5394 return NULL;
5395 }
5396
5397
5398 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5399 PyObject *resultobj = 0;
5400 wxString result;
5401
5402 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5403 {
5404 PyThreadState* __tstate = wxPyBeginAllowThreads();
5405 result = wxGetUserName();
5406 wxPyEndAllowThreads(__tstate);
5407 if (PyErr_Occurred()) SWIG_fail;
5408 }
5409 {
5410 #if wxUSE_UNICODE
5411 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5412 #else
5413 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5414 #endif
5415 }
5416 return resultobj;
5417 fail:
5418 return NULL;
5419 }
5420
5421
5422 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5423 PyObject *resultobj = 0;
5424 wxString result;
5425
5426 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5427 {
5428 PyThreadState* __tstate = wxPyBeginAllowThreads();
5429 result = wxGetHomeDir();
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 {
5434 #if wxUSE_UNICODE
5435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5436 #else
5437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5438 #endif
5439 }
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5447 PyObject *resultobj = 0;
5448 wxString const &arg1_defvalue = wxPyEmptyString ;
5449 wxString *arg1 = (wxString *) &arg1_defvalue ;
5450 wxString result;
5451 bool temp1 = false ;
5452 PyObject * obj0 = 0 ;
5453 char * kwnames[] = {
5454 (char *) "user", NULL
5455 };
5456
5457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5458 if (obj0) {
5459 {
5460 arg1 = wxString_in_helper(obj0);
5461 if (arg1 == NULL) SWIG_fail;
5462 temp1 = true;
5463 }
5464 }
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = wxGetUserHome((wxString const &)*arg1);
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 {
5472 #if wxUSE_UNICODE
5473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5474 #else
5475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5476 #endif
5477 }
5478 {
5479 if (temp1)
5480 delete arg1;
5481 }
5482 return resultobj;
5483 fail:
5484 {
5485 if (temp1)
5486 delete arg1;
5487 }
5488 return NULL;
5489 }
5490
5491
5492 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5493 PyObject *resultobj = 0;
5494 unsigned long result;
5495
5496 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = (unsigned long)wxGetProcessId();
5500 wxPyEndAllowThreads(__tstate);
5501 if (PyErr_Occurred()) SWIG_fail;
5502 }
5503 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5504 return resultobj;
5505 fail:
5506 return NULL;
5507 }
5508
5509
5510 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5511 PyObject *resultobj = 0;
5512
5513 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5514 {
5515 PyThreadState* __tstate = wxPyBeginAllowThreads();
5516 wxTrap();
5517 wxPyEndAllowThreads(__tstate);
5518 if (PyErr_Occurred()) SWIG_fail;
5519 }
5520 resultobj = SWIG_Py_Void();
5521 return resultobj;
5522 fail:
5523 return NULL;
5524 }
5525
5526
5527 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5528 PyObject *resultobj = 0;
5529 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5530 wxString *arg1 = (wxString *) &arg1_defvalue ;
5531 wxString const &arg2_defvalue = wxPyEmptyString ;
5532 wxString *arg2 = (wxString *) &arg2_defvalue ;
5533 wxString const &arg3_defvalue = wxPyEmptyString ;
5534 wxString *arg3 = (wxString *) &arg3_defvalue ;
5535 wxString const &arg4_defvalue = wxPyEmptyString ;
5536 wxString *arg4 = (wxString *) &arg4_defvalue ;
5537 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5538 wxString *arg5 = (wxString *) &arg5_defvalue ;
5539 int arg6 = (int) 0 ;
5540 wxWindow *arg7 = (wxWindow *) NULL ;
5541 int arg8 = (int) -1 ;
5542 int arg9 = (int) -1 ;
5543 wxString result;
5544 bool temp1 = false ;
5545 bool temp2 = false ;
5546 bool temp3 = false ;
5547 bool temp4 = false ;
5548 bool temp5 = false ;
5549 int val6 ;
5550 int ecode6 = 0 ;
5551 void *argp7 = 0 ;
5552 int res7 = 0 ;
5553 int val8 ;
5554 int ecode8 = 0 ;
5555 int val9 ;
5556 int ecode9 = 0 ;
5557 PyObject * obj0 = 0 ;
5558 PyObject * obj1 = 0 ;
5559 PyObject * obj2 = 0 ;
5560 PyObject * obj3 = 0 ;
5561 PyObject * obj4 = 0 ;
5562 PyObject * obj5 = 0 ;
5563 PyObject * obj6 = 0 ;
5564 PyObject * obj7 = 0 ;
5565 PyObject * obj8 = 0 ;
5566 char * kwnames[] = {
5567 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5568 };
5569
5570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5571 if (obj0) {
5572 {
5573 arg1 = wxString_in_helper(obj0);
5574 if (arg1 == NULL) SWIG_fail;
5575 temp1 = true;
5576 }
5577 }
5578 if (obj1) {
5579 {
5580 arg2 = wxString_in_helper(obj1);
5581 if (arg2 == NULL) SWIG_fail;
5582 temp2 = true;
5583 }
5584 }
5585 if (obj2) {
5586 {
5587 arg3 = wxString_in_helper(obj2);
5588 if (arg3 == NULL) SWIG_fail;
5589 temp3 = true;
5590 }
5591 }
5592 if (obj3) {
5593 {
5594 arg4 = wxString_in_helper(obj3);
5595 if (arg4 == NULL) SWIG_fail;
5596 temp4 = true;
5597 }
5598 }
5599 if (obj4) {
5600 {
5601 arg5 = wxString_in_helper(obj4);
5602 if (arg5 == NULL) SWIG_fail;
5603 temp5 = true;
5604 }
5605 }
5606 if (obj5) {
5607 ecode6 = SWIG_AsVal_int(obj5, &val6);
5608 if (!SWIG_IsOK(ecode6)) {
5609 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5610 }
5611 arg6 = static_cast< int >(val6);
5612 }
5613 if (obj6) {
5614 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5615 if (!SWIG_IsOK(res7)) {
5616 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5617 }
5618 arg7 = reinterpret_cast< wxWindow * >(argp7);
5619 }
5620 if (obj7) {
5621 ecode8 = SWIG_AsVal_int(obj7, &val8);
5622 if (!SWIG_IsOK(ecode8)) {
5623 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5624 }
5625 arg8 = static_cast< int >(val8);
5626 }
5627 if (obj8) {
5628 ecode9 = SWIG_AsVal_int(obj8, &val9);
5629 if (!SWIG_IsOK(ecode9)) {
5630 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5631 }
5632 arg9 = static_cast< int >(val9);
5633 }
5634 {
5635 if (!wxPyCheckForApp()) SWIG_fail;
5636 PyThreadState* __tstate = wxPyBeginAllowThreads();
5637 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 #if wxUSE_UNICODE
5643 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5644 #else
5645 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5646 #endif
5647 }
5648 {
5649 if (temp1)
5650 delete arg1;
5651 }
5652 {
5653 if (temp2)
5654 delete arg2;
5655 }
5656 {
5657 if (temp3)
5658 delete arg3;
5659 }
5660 {
5661 if (temp4)
5662 delete arg4;
5663 }
5664 {
5665 if (temp5)
5666 delete arg5;
5667 }
5668 return resultobj;
5669 fail:
5670 {
5671 if (temp1)
5672 delete arg1;
5673 }
5674 {
5675 if (temp2)
5676 delete arg2;
5677 }
5678 {
5679 if (temp3)
5680 delete arg3;
5681 }
5682 {
5683 if (temp4)
5684 delete arg4;
5685 }
5686 {
5687 if (temp5)
5688 delete arg5;
5689 }
5690 return NULL;
5691 }
5692
5693
5694 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj = 0;
5696 wxString *arg1 = 0 ;
5697 wxString *arg2 = 0 ;
5698 wxString const &arg3_defvalue = wxPyEmptyString ;
5699 wxString *arg3 = (wxString *) &arg3_defvalue ;
5700 wxWindow *arg4 = (wxWindow *) NULL ;
5701 wxString result;
5702 bool temp1 = false ;
5703 bool temp2 = false ;
5704 bool temp3 = false ;
5705 void *argp4 = 0 ;
5706 int res4 = 0 ;
5707 PyObject * obj0 = 0 ;
5708 PyObject * obj1 = 0 ;
5709 PyObject * obj2 = 0 ;
5710 PyObject * obj3 = 0 ;
5711 char * kwnames[] = {
5712 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5713 };
5714
5715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5716 {
5717 arg1 = wxString_in_helper(obj0);
5718 if (arg1 == NULL) SWIG_fail;
5719 temp1 = true;
5720 }
5721 {
5722 arg2 = wxString_in_helper(obj1);
5723 if (arg2 == NULL) SWIG_fail;
5724 temp2 = true;
5725 }
5726 if (obj2) {
5727 {
5728 arg3 = wxString_in_helper(obj2);
5729 if (arg3 == NULL) SWIG_fail;
5730 temp3 = true;
5731 }
5732 }
5733 if (obj3) {
5734 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5735 if (!SWIG_IsOK(res4)) {
5736 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5737 }
5738 arg4 = reinterpret_cast< wxWindow * >(argp4);
5739 }
5740 {
5741 if (!wxPyCheckForApp()) SWIG_fail;
5742 PyThreadState* __tstate = wxPyBeginAllowThreads();
5743 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5744 wxPyEndAllowThreads(__tstate);
5745 if (PyErr_Occurred()) SWIG_fail;
5746 }
5747 {
5748 #if wxUSE_UNICODE
5749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5750 #else
5751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5752 #endif
5753 }
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 return resultobj;
5767 fail:
5768 {
5769 if (temp1)
5770 delete arg1;
5771 }
5772 {
5773 if (temp2)
5774 delete arg2;
5775 }
5776 {
5777 if (temp3)
5778 delete arg3;
5779 }
5780 return NULL;
5781 }
5782
5783
5784 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj = 0;
5786 wxString *arg1 = 0 ;
5787 wxString *arg2 = 0 ;
5788 wxString const &arg3_defvalue = wxPyEmptyString ;
5789 wxString *arg3 = (wxString *) &arg3_defvalue ;
5790 wxWindow *arg4 = (wxWindow *) NULL ;
5791 wxString result;
5792 bool temp1 = false ;
5793 bool temp2 = false ;
5794 bool temp3 = false ;
5795 void *argp4 = 0 ;
5796 int res4 = 0 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 PyObject * obj2 = 0 ;
5800 PyObject * obj3 = 0 ;
5801 char * kwnames[] = {
5802 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5803 };
5804
5805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5806 {
5807 arg1 = wxString_in_helper(obj0);
5808 if (arg1 == NULL) SWIG_fail;
5809 temp1 = true;
5810 }
5811 {
5812 arg2 = wxString_in_helper(obj1);
5813 if (arg2 == NULL) SWIG_fail;
5814 temp2 = true;
5815 }
5816 if (obj2) {
5817 {
5818 arg3 = wxString_in_helper(obj2);
5819 if (arg3 == NULL) SWIG_fail;
5820 temp3 = true;
5821 }
5822 }
5823 if (obj3) {
5824 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5825 if (!SWIG_IsOK(res4)) {
5826 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5827 }
5828 arg4 = reinterpret_cast< wxWindow * >(argp4);
5829 }
5830 {
5831 if (!wxPyCheckForApp()) SWIG_fail;
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5834 wxPyEndAllowThreads(__tstate);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 #if wxUSE_UNICODE
5839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5840 #else
5841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5842 #endif
5843 }
5844 {
5845 if (temp1)
5846 delete arg1;
5847 }
5848 {
5849 if (temp2)
5850 delete arg2;
5851 }
5852 {
5853 if (temp3)
5854 delete arg3;
5855 }
5856 return resultobj;
5857 fail:
5858 {
5859 if (temp1)
5860 delete arg1;
5861 }
5862 {
5863 if (temp2)
5864 delete arg2;
5865 }
5866 {
5867 if (temp3)
5868 delete arg3;
5869 }
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj = 0;
5876 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5877 wxString *arg1 = (wxString *) &arg1_defvalue ;
5878 wxString const &arg2_defvalue = wxPyEmptyString ;
5879 wxString *arg2 = (wxString *) &arg2_defvalue ;
5880 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5881 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5882 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5883 wxWindow *arg5 = (wxWindow *) NULL ;
5884 wxString result;
5885 bool temp1 = false ;
5886 bool temp2 = false ;
5887 long val3 ;
5888 int ecode3 = 0 ;
5889 wxPoint temp4 ;
5890 void *argp5 = 0 ;
5891 int res5 = 0 ;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 PyObject * obj2 = 0 ;
5895 PyObject * obj3 = 0 ;
5896 PyObject * obj4 = 0 ;
5897 char * kwnames[] = {
5898 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5899 };
5900
5901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5902 if (obj0) {
5903 {
5904 arg1 = wxString_in_helper(obj0);
5905 if (arg1 == NULL) SWIG_fail;
5906 temp1 = true;
5907 }
5908 }
5909 if (obj1) {
5910 {
5911 arg2 = wxString_in_helper(obj1);
5912 if (arg2 == NULL) SWIG_fail;
5913 temp2 = true;
5914 }
5915 }
5916 if (obj2) {
5917 ecode3 = SWIG_AsVal_long(obj2, &val3);
5918 if (!SWIG_IsOK(ecode3)) {
5919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5920 }
5921 arg3 = static_cast< long >(val3);
5922 }
5923 if (obj3) {
5924 {
5925 arg4 = &temp4;
5926 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5927 }
5928 }
5929 if (obj4) {
5930 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5931 if (!SWIG_IsOK(res5)) {
5932 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5933 }
5934 arg5 = reinterpret_cast< wxWindow * >(argp5);
5935 }
5936 {
5937 if (!wxPyCheckForApp()) SWIG_fail;
5938 PyThreadState* __tstate = wxPyBeginAllowThreads();
5939 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5940 wxPyEndAllowThreads(__tstate);
5941 if (PyErr_Occurred()) SWIG_fail;
5942 }
5943 {
5944 #if wxUSE_UNICODE
5945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5946 #else
5947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5948 #endif
5949 }
5950 {
5951 if (temp1)
5952 delete arg1;
5953 }
5954 {
5955 if (temp2)
5956 delete arg2;
5957 }
5958 return resultobj;
5959 fail:
5960 {
5961 if (temp1)
5962 delete arg1;
5963 }
5964 {
5965 if (temp2)
5966 delete arg2;
5967 }
5968 return NULL;
5969 }
5970
5971
5972 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5973 PyObject *resultobj = 0;
5974 wxString *arg1 = 0 ;
5975 wxString const &arg2_defvalue = wxPyEmptyString ;
5976 wxString *arg2 = (wxString *) &arg2_defvalue ;
5977 wxString const &arg3_defvalue = wxPyEmptyString ;
5978 wxString *arg3 = (wxString *) &arg3_defvalue ;
5979 wxWindow *arg4 = (wxWindow *) NULL ;
5980 int arg5 = (int) -1 ;
5981 int arg6 = (int) -1 ;
5982 bool arg7 = (bool) true ;
5983 wxString result;
5984 bool temp1 = false ;
5985 bool temp2 = false ;
5986 bool temp3 = false ;
5987 void *argp4 = 0 ;
5988 int res4 = 0 ;
5989 int val5 ;
5990 int ecode5 = 0 ;
5991 int val6 ;
5992 int ecode6 = 0 ;
5993 bool val7 ;
5994 int ecode7 = 0 ;
5995 PyObject * obj0 = 0 ;
5996 PyObject * obj1 = 0 ;
5997 PyObject * obj2 = 0 ;
5998 PyObject * obj3 = 0 ;
5999 PyObject * obj4 = 0 ;
6000 PyObject * obj5 = 0 ;
6001 PyObject * obj6 = 0 ;
6002 char * kwnames[] = {
6003 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
6004 };
6005
6006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
6007 {
6008 arg1 = wxString_in_helper(obj0);
6009 if (arg1 == NULL) SWIG_fail;
6010 temp1 = true;
6011 }
6012 if (obj1) {
6013 {
6014 arg2 = wxString_in_helper(obj1);
6015 if (arg2 == NULL) SWIG_fail;
6016 temp2 = true;
6017 }
6018 }
6019 if (obj2) {
6020 {
6021 arg3 = wxString_in_helper(obj2);
6022 if (arg3 == NULL) SWIG_fail;
6023 temp3 = true;
6024 }
6025 }
6026 if (obj3) {
6027 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6028 if (!SWIG_IsOK(res4)) {
6029 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6030 }
6031 arg4 = reinterpret_cast< wxWindow * >(argp4);
6032 }
6033 if (obj4) {
6034 ecode5 = SWIG_AsVal_int(obj4, &val5);
6035 if (!SWIG_IsOK(ecode5)) {
6036 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6037 }
6038 arg5 = static_cast< int >(val5);
6039 }
6040 if (obj5) {
6041 ecode6 = SWIG_AsVal_int(obj5, &val6);
6042 if (!SWIG_IsOK(ecode6)) {
6043 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6044 }
6045 arg6 = static_cast< int >(val6);
6046 }
6047 if (obj6) {
6048 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6049 if (!SWIG_IsOK(ecode7)) {
6050 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6051 }
6052 arg7 = static_cast< bool >(val7);
6053 }
6054 {
6055 if (!wxPyCheckForApp()) SWIG_fail;
6056 PyThreadState* __tstate = wxPyBeginAllowThreads();
6057 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6058 wxPyEndAllowThreads(__tstate);
6059 if (PyErr_Occurred()) SWIG_fail;
6060 }
6061 {
6062 #if wxUSE_UNICODE
6063 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6064 #else
6065 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6066 #endif
6067 }
6068 {
6069 if (temp1)
6070 delete arg1;
6071 }
6072 {
6073 if (temp2)
6074 delete arg2;
6075 }
6076 {
6077 if (temp3)
6078 delete arg3;
6079 }
6080 return resultobj;
6081 fail:
6082 {
6083 if (temp1)
6084 delete arg1;
6085 }
6086 {
6087 if (temp2)
6088 delete arg2;
6089 }
6090 {
6091 if (temp3)
6092 delete arg3;
6093 }
6094 return NULL;
6095 }
6096
6097
6098 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6099 PyObject *resultobj = 0;
6100 wxString *arg1 = 0 ;
6101 wxString const &arg2_defvalue = wxPyEmptyString ;
6102 wxString *arg2 = (wxString *) &arg2_defvalue ;
6103 wxString const &arg3_defvalue = wxPyEmptyString ;
6104 wxString *arg3 = (wxString *) &arg3_defvalue ;
6105 wxWindow *arg4 = (wxWindow *) NULL ;
6106 wxString result;
6107 bool temp1 = false ;
6108 bool temp2 = false ;
6109 bool temp3 = false ;
6110 void *argp4 = 0 ;
6111 int res4 = 0 ;
6112 PyObject * obj0 = 0 ;
6113 PyObject * obj1 = 0 ;
6114 PyObject * obj2 = 0 ;
6115 PyObject * obj3 = 0 ;
6116 char * kwnames[] = {
6117 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6118 };
6119
6120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6121 {
6122 arg1 = wxString_in_helper(obj0);
6123 if (arg1 == NULL) SWIG_fail;
6124 temp1 = true;
6125 }
6126 if (obj1) {
6127 {
6128 arg2 = wxString_in_helper(obj1);
6129 if (arg2 == NULL) SWIG_fail;
6130 temp2 = true;
6131 }
6132 }
6133 if (obj2) {
6134 {
6135 arg3 = wxString_in_helper(obj2);
6136 if (arg3 == NULL) SWIG_fail;
6137 temp3 = true;
6138 }
6139 }
6140 if (obj3) {
6141 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6142 if (!SWIG_IsOK(res4)) {
6143 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6144 }
6145 arg4 = reinterpret_cast< wxWindow * >(argp4);
6146 }
6147 {
6148 if (!wxPyCheckForApp()) SWIG_fail;
6149 PyThreadState* __tstate = wxPyBeginAllowThreads();
6150 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6151 wxPyEndAllowThreads(__tstate);
6152 if (PyErr_Occurred()) SWIG_fail;
6153 }
6154 {
6155 #if wxUSE_UNICODE
6156 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6157 #else
6158 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6159 #endif
6160 }
6161 {
6162 if (temp1)
6163 delete arg1;
6164 }
6165 {
6166 if (temp2)
6167 delete arg2;
6168 }
6169 {
6170 if (temp3)
6171 delete arg3;
6172 }
6173 return resultobj;
6174 fail:
6175 {
6176 if (temp1)
6177 delete arg1;
6178 }
6179 {
6180 if (temp2)
6181 delete arg2;
6182 }
6183 {
6184 if (temp3)
6185 delete arg3;
6186 }
6187 return NULL;
6188 }
6189
6190
6191 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6192 PyObject *resultobj = 0;
6193 wxString *arg1 = 0 ;
6194 wxString *arg2 = 0 ;
6195 int arg3 ;
6196 wxString *arg4 = (wxString *) 0 ;
6197 wxWindow *arg5 = (wxWindow *) NULL ;
6198 int arg6 = (int) -1 ;
6199 int arg7 = (int) -1 ;
6200 bool arg8 = (bool) true ;
6201 int arg9 = (int) 150 ;
6202 int arg10 = (int) 200 ;
6203 wxString result;
6204 bool temp1 = false ;
6205 bool temp2 = false ;
6206 void *argp5 = 0 ;
6207 int res5 = 0 ;
6208 int val6 ;
6209 int ecode6 = 0 ;
6210 int val7 ;
6211 int ecode7 = 0 ;
6212 bool val8 ;
6213 int ecode8 = 0 ;
6214 int val9 ;
6215 int ecode9 = 0 ;
6216 int val10 ;
6217 int ecode10 = 0 ;
6218 PyObject * obj0 = 0 ;
6219 PyObject * obj1 = 0 ;
6220 PyObject * obj2 = 0 ;
6221 PyObject * obj3 = 0 ;
6222 PyObject * obj4 = 0 ;
6223 PyObject * obj5 = 0 ;
6224 PyObject * obj6 = 0 ;
6225 PyObject * obj7 = 0 ;
6226 PyObject * obj8 = 0 ;
6227 char * kwnames[] = {
6228 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6229 };
6230
6231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6232 {
6233 arg1 = wxString_in_helper(obj0);
6234 if (arg1 == NULL) SWIG_fail;
6235 temp1 = true;
6236 }
6237 {
6238 arg2 = wxString_in_helper(obj1);
6239 if (arg2 == NULL) SWIG_fail;
6240 temp2 = true;
6241 }
6242 {
6243 arg3 = PyList_Size(obj2);
6244 arg4 = wxString_LIST_helper(obj2);
6245 if (arg4 == NULL) SWIG_fail;
6246 }
6247 if (obj3) {
6248 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6249 if (!SWIG_IsOK(res5)) {
6250 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6251 }
6252 arg5 = reinterpret_cast< wxWindow * >(argp5);
6253 }
6254 if (obj4) {
6255 ecode6 = SWIG_AsVal_int(obj4, &val6);
6256 if (!SWIG_IsOK(ecode6)) {
6257 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6258 }
6259 arg6 = static_cast< int >(val6);
6260 }
6261 if (obj5) {
6262 ecode7 = SWIG_AsVal_int(obj5, &val7);
6263 if (!SWIG_IsOK(ecode7)) {
6264 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6265 }
6266 arg7 = static_cast< int >(val7);
6267 }
6268 if (obj6) {
6269 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6270 if (!SWIG_IsOK(ecode8)) {
6271 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6272 }
6273 arg8 = static_cast< bool >(val8);
6274 }
6275 if (obj7) {
6276 ecode9 = SWIG_AsVal_int(obj7, &val9);
6277 if (!SWIG_IsOK(ecode9)) {
6278 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6279 }
6280 arg9 = static_cast< int >(val9);
6281 }
6282 if (obj8) {
6283 ecode10 = SWIG_AsVal_int(obj8, &val10);
6284 if (!SWIG_IsOK(ecode10)) {
6285 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6286 }
6287 arg10 = static_cast< int >(val10);
6288 }
6289 {
6290 if (!wxPyCheckForApp()) SWIG_fail;
6291 PyThreadState* __tstate = wxPyBeginAllowThreads();
6292 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6293 wxPyEndAllowThreads(__tstate);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 {
6297 #if wxUSE_UNICODE
6298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6299 #else
6300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6301 #endif
6302 }
6303 {
6304 if (temp1)
6305 delete arg1;
6306 }
6307 {
6308 if (temp2)
6309 delete arg2;
6310 }
6311 {
6312 if (arg4) delete [] arg4;
6313 }
6314 return resultobj;
6315 fail:
6316 {
6317 if (temp1)
6318 delete arg1;
6319 }
6320 {
6321 if (temp2)
6322 delete arg2;
6323 }
6324 {
6325 if (arg4) delete [] arg4;
6326 }
6327 return NULL;
6328 }
6329
6330
6331 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6332 PyObject *resultobj = 0;
6333 wxString *arg1 = 0 ;
6334 wxString *arg2 = 0 ;
6335 int arg3 ;
6336 wxString *arg4 = (wxString *) 0 ;
6337 wxWindow *arg5 = (wxWindow *) NULL ;
6338 int arg6 = (int) -1 ;
6339 int arg7 = (int) -1 ;
6340 bool arg8 = (bool) true ;
6341 int arg9 = (int) 150 ;
6342 int arg10 = (int) 200 ;
6343 int result;
6344 bool temp1 = false ;
6345 bool temp2 = false ;
6346 void *argp5 = 0 ;
6347 int res5 = 0 ;
6348 int val6 ;
6349 int ecode6 = 0 ;
6350 int val7 ;
6351 int ecode7 = 0 ;
6352 bool val8 ;
6353 int ecode8 = 0 ;
6354 int val9 ;
6355 int ecode9 = 0 ;
6356 int val10 ;
6357 int ecode10 = 0 ;
6358 PyObject * obj0 = 0 ;
6359 PyObject * obj1 = 0 ;
6360 PyObject * obj2 = 0 ;
6361 PyObject * obj3 = 0 ;
6362 PyObject * obj4 = 0 ;
6363 PyObject * obj5 = 0 ;
6364 PyObject * obj6 = 0 ;
6365 PyObject * obj7 = 0 ;
6366 PyObject * obj8 = 0 ;
6367 char * kwnames[] = {
6368 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6369 };
6370
6371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6372 {
6373 arg1 = wxString_in_helper(obj0);
6374 if (arg1 == NULL) SWIG_fail;
6375 temp1 = true;
6376 }
6377 {
6378 arg2 = wxString_in_helper(obj1);
6379 if (arg2 == NULL) SWIG_fail;
6380 temp2 = true;
6381 }
6382 {
6383 arg3 = PyList_Size(obj2);
6384 arg4 = wxString_LIST_helper(obj2);
6385 if (arg4 == NULL) SWIG_fail;
6386 }
6387 if (obj3) {
6388 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6389 if (!SWIG_IsOK(res5)) {
6390 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6391 }
6392 arg5 = reinterpret_cast< wxWindow * >(argp5);
6393 }
6394 if (obj4) {
6395 ecode6 = SWIG_AsVal_int(obj4, &val6);
6396 if (!SWIG_IsOK(ecode6)) {
6397 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6398 }
6399 arg6 = static_cast< int >(val6);
6400 }
6401 if (obj5) {
6402 ecode7 = SWIG_AsVal_int(obj5, &val7);
6403 if (!SWIG_IsOK(ecode7)) {
6404 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6405 }
6406 arg7 = static_cast< int >(val7);
6407 }
6408 if (obj6) {
6409 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6410 if (!SWIG_IsOK(ecode8)) {
6411 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6412 }
6413 arg8 = static_cast< bool >(val8);
6414 }
6415 if (obj7) {
6416 ecode9 = SWIG_AsVal_int(obj7, &val9);
6417 if (!SWIG_IsOK(ecode9)) {
6418 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6419 }
6420 arg9 = static_cast< int >(val9);
6421 }
6422 if (obj8) {
6423 ecode10 = SWIG_AsVal_int(obj8, &val10);
6424 if (!SWIG_IsOK(ecode10)) {
6425 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6426 }
6427 arg10 = static_cast< int >(val10);
6428 }
6429 {
6430 if (!wxPyCheckForApp()) SWIG_fail;
6431 PyThreadState* __tstate = wxPyBeginAllowThreads();
6432 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 resultobj = SWIG_From_int(static_cast< int >(result));
6437 {
6438 if (temp1)
6439 delete arg1;
6440 }
6441 {
6442 if (temp2)
6443 delete arg2;
6444 }
6445 {
6446 if (arg4) delete [] arg4;
6447 }
6448 return resultobj;
6449 fail:
6450 {
6451 if (temp1)
6452 delete arg1;
6453 }
6454 {
6455 if (temp2)
6456 delete arg2;
6457 }
6458 {
6459 if (arg4) delete [] arg4;
6460 }
6461 return NULL;
6462 }
6463
6464
6465 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj = 0;
6467 wxString *arg1 = 0 ;
6468 wxString const &arg2_defvalue = wxPyEmptyString ;
6469 wxString *arg2 = (wxString *) &arg2_defvalue ;
6470 int arg3 = (int) wxOK|wxCENTRE ;
6471 wxWindow *arg4 = (wxWindow *) NULL ;
6472 int arg5 = (int) -1 ;
6473 int arg6 = (int) -1 ;
6474 int result;
6475 bool temp1 = false ;
6476 bool temp2 = false ;
6477 int val3 ;
6478 int ecode3 = 0 ;
6479 void *argp4 = 0 ;
6480 int res4 = 0 ;
6481 int val5 ;
6482 int ecode5 = 0 ;
6483 int val6 ;
6484 int ecode6 = 0 ;
6485 PyObject * obj0 = 0 ;
6486 PyObject * obj1 = 0 ;
6487 PyObject * obj2 = 0 ;
6488 PyObject * obj3 = 0 ;
6489 PyObject * obj4 = 0 ;
6490 PyObject * obj5 = 0 ;
6491 char * kwnames[] = {
6492 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6493 };
6494
6495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6496 {
6497 arg1 = wxString_in_helper(obj0);
6498 if (arg1 == NULL) SWIG_fail;
6499 temp1 = true;
6500 }
6501 if (obj1) {
6502 {
6503 arg2 = wxString_in_helper(obj1);
6504 if (arg2 == NULL) SWIG_fail;
6505 temp2 = true;
6506 }
6507 }
6508 if (obj2) {
6509 ecode3 = SWIG_AsVal_int(obj2, &val3);
6510 if (!SWIG_IsOK(ecode3)) {
6511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6512 }
6513 arg3 = static_cast< int >(val3);
6514 }
6515 if (obj3) {
6516 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6517 if (!SWIG_IsOK(res4)) {
6518 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6519 }
6520 arg4 = reinterpret_cast< wxWindow * >(argp4);
6521 }
6522 if (obj4) {
6523 ecode5 = SWIG_AsVal_int(obj4, &val5);
6524 if (!SWIG_IsOK(ecode5)) {
6525 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6526 }
6527 arg5 = static_cast< int >(val5);
6528 }
6529 if (obj5) {
6530 ecode6 = SWIG_AsVal_int(obj5, &val6);
6531 if (!SWIG_IsOK(ecode6)) {
6532 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6533 }
6534 arg6 = static_cast< int >(val6);
6535 }
6536 {
6537 if (!wxPyCheckForApp()) SWIG_fail;
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 resultobj = SWIG_From_int(static_cast< int >(result));
6544 {
6545 if (temp1)
6546 delete arg1;
6547 }
6548 {
6549 if (temp2)
6550 delete arg2;
6551 }
6552 return resultobj;
6553 fail:
6554 {
6555 if (temp1)
6556 delete arg1;
6557 }
6558 {
6559 if (temp2)
6560 delete arg2;
6561 }
6562 return NULL;
6563 }
6564
6565
6566 SWIGINTERN PyObject *_wrap_GetNumberFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6567 PyObject *resultobj = 0;
6568 wxString *arg1 = 0 ;
6569 wxString *arg2 = 0 ;
6570 wxString *arg3 = 0 ;
6571 long arg4 ;
6572 long arg5 = (long) 0 ;
6573 long arg6 = (long) 100 ;
6574 wxWindow *arg7 = (wxWindow *) NULL ;
6575 wxPoint const &arg8_defvalue = wxDefaultPosition ;
6576 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
6577 long result;
6578 bool temp1 = false ;
6579 bool temp2 = false ;
6580 bool temp3 = false ;
6581 long val4 ;
6582 int ecode4 = 0 ;
6583 long val5 ;
6584 int ecode5 = 0 ;
6585 long val6 ;
6586 int ecode6 = 0 ;
6587 void *argp7 = 0 ;
6588 int res7 = 0 ;
6589 wxPoint temp8 ;
6590 PyObject * obj0 = 0 ;
6591 PyObject * obj1 = 0 ;
6592 PyObject * obj2 = 0 ;
6593 PyObject * obj3 = 0 ;
6594 PyObject * obj4 = 0 ;
6595 PyObject * obj5 = 0 ;
6596 PyObject * obj6 = 0 ;
6597 PyObject * obj7 = 0 ;
6598 char * kwnames[] = {
6599 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
6600 };
6601
6602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
6603 {
6604 arg1 = wxString_in_helper(obj0);
6605 if (arg1 == NULL) SWIG_fail;
6606 temp1 = true;
6607 }
6608 {
6609 arg2 = wxString_in_helper(obj1);
6610 if (arg2 == NULL) SWIG_fail;
6611 temp2 = true;
6612 }
6613 {
6614 arg3 = wxString_in_helper(obj2);
6615 if (arg3 == NULL) SWIG_fail;
6616 temp3 = true;
6617 }
6618 ecode4 = SWIG_AsVal_long(obj3, &val4);
6619 if (!SWIG_IsOK(ecode4)) {
6620 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GetNumberFromUser" "', expected argument " "4"" of type '" "long""'");
6621 }
6622 arg4 = static_cast< long >(val4);
6623 if (obj4) {
6624 ecode5 = SWIG_AsVal_long(obj4, &val5);
6625 if (!SWIG_IsOK(ecode5)) {
6626 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetNumberFromUser" "', expected argument " "5"" of type '" "long""'");
6627 }
6628 arg5 = static_cast< long >(val5);
6629 }
6630 if (obj5) {
6631 ecode6 = SWIG_AsVal_long(obj5, &val6);
6632 if (!SWIG_IsOK(ecode6)) {
6633 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetNumberFromUser" "', expected argument " "6"" of type '" "long""'");
6634 }
6635 arg6 = static_cast< long >(val6);
6636 }
6637 if (obj6) {
6638 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
6639 if (!SWIG_IsOK(res7)) {
6640 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GetNumberFromUser" "', expected argument " "7"" of type '" "wxWindow *""'");
6641 }
6642 arg7 = reinterpret_cast< wxWindow * >(argp7);
6643 }
6644 if (obj7) {
6645 {
6646 arg8 = &temp8;
6647 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
6648 }
6649 }
6650 {
6651 if (!wxPyCheckForApp()) SWIG_fail;
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
6654 wxPyEndAllowThreads(__tstate);
6655 if (PyErr_Occurred()) SWIG_fail;
6656 }
6657 resultobj = SWIG_From_long(static_cast< long >(result));
6658 {
6659 if (temp1)
6660 delete arg1;
6661 }
6662 {
6663 if (temp2)
6664 delete arg2;
6665 }
6666 {
6667 if (temp3)
6668 delete arg3;
6669 }
6670 return resultobj;
6671 fail:
6672 {
6673 if (temp1)
6674 delete arg1;
6675 }
6676 {
6677 if (temp2)
6678 delete arg2;
6679 }
6680 {
6681 if (temp3)
6682 delete arg3;
6683 }
6684 return NULL;
6685 }
6686
6687
6688 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6689 PyObject *resultobj = 0;
6690 bool result;
6691
6692 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6693 {
6694 if (!wxPyCheckForApp()) SWIG_fail;
6695 PyThreadState* __tstate = wxPyBeginAllowThreads();
6696 result = (bool)wxColourDisplay();
6697 wxPyEndAllowThreads(__tstate);
6698 if (PyErr_Occurred()) SWIG_fail;
6699 }
6700 {
6701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6702 }
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6710 PyObject *resultobj = 0;
6711 int result;
6712
6713 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6714 {
6715 if (!wxPyCheckForApp()) SWIG_fail;
6716 PyThreadState* __tstate = wxPyBeginAllowThreads();
6717 result = (int)wxDisplayDepth();
6718 wxPyEndAllowThreads(__tstate);
6719 if (PyErr_Occurred()) SWIG_fail;
6720 }
6721 resultobj = SWIG_From_int(static_cast< int >(result));
6722 return resultobj;
6723 fail:
6724 return NULL;
6725 }
6726
6727
6728 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6729 PyObject *resultobj = 0;
6730 int result;
6731
6732 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6733 {
6734 if (!wxPyCheckForApp()) SWIG_fail;
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 result = (int)wxGetDisplayDepth();
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 resultobj = SWIG_From_int(static_cast< int >(result));
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6748 PyObject *resultobj = 0;
6749 int *arg1 = (int *) 0 ;
6750 int *arg2 = (int *) 0 ;
6751 int temp1 ;
6752 int res1 = SWIG_TMPOBJ ;
6753 int temp2 ;
6754 int res2 = SWIG_TMPOBJ ;
6755
6756 arg1 = &temp1;
6757 arg2 = &temp2;
6758 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6759 {
6760 if (!wxPyCheckForApp()) SWIG_fail;
6761 PyThreadState* __tstate = wxPyBeginAllowThreads();
6762 wxDisplaySize(arg1,arg2);
6763 wxPyEndAllowThreads(__tstate);
6764 if (PyErr_Occurred()) SWIG_fail;
6765 }
6766 resultobj = SWIG_Py_Void();
6767 if (SWIG_IsTmpObj(res1)) {
6768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6769 } else {
6770 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6772 }
6773 if (SWIG_IsTmpObj(res2)) {
6774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6775 } else {
6776 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6777 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6778 }
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6786 PyObject *resultobj = 0;
6787 wxSize result;
6788
6789 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6790 {
6791 if (!wxPyCheckForApp()) SWIG_fail;
6792 PyThreadState* __tstate = wxPyBeginAllowThreads();
6793 result = wxGetDisplaySize();
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6805 PyObject *resultobj = 0;
6806 int *arg1 = (int *) 0 ;
6807 int *arg2 = (int *) 0 ;
6808 int temp1 ;
6809 int res1 = SWIG_TMPOBJ ;
6810 int temp2 ;
6811 int res2 = SWIG_TMPOBJ ;
6812
6813 arg1 = &temp1;
6814 arg2 = &temp2;
6815 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6816 {
6817 if (!wxPyCheckForApp()) SWIG_fail;
6818 PyThreadState* __tstate = wxPyBeginAllowThreads();
6819 wxDisplaySizeMM(arg1,arg2);
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 resultobj = SWIG_Py_Void();
6824 if (SWIG_IsTmpObj(res1)) {
6825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6826 } else {
6827 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6829 }
6830 if (SWIG_IsTmpObj(res2)) {
6831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6832 } else {
6833 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6835 }
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6843 PyObject *resultobj = 0;
6844 wxSize result;
6845
6846 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6847 {
6848 if (!wxPyCheckForApp()) SWIG_fail;
6849 PyThreadState* __tstate = wxPyBeginAllowThreads();
6850 result = wxGetDisplaySizeMM();
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6855 return resultobj;
6856 fail:
6857 return NULL;
6858 }
6859
6860
6861 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6862 PyObject *resultobj = 0;
6863 int *arg1 = (int *) 0 ;
6864 int *arg2 = (int *) 0 ;
6865 int *arg3 = (int *) 0 ;
6866 int *arg4 = (int *) 0 ;
6867 int temp1 ;
6868 int res1 = SWIG_TMPOBJ ;
6869 int temp2 ;
6870 int res2 = SWIG_TMPOBJ ;
6871 int temp3 ;
6872 int res3 = SWIG_TMPOBJ ;
6873 int temp4 ;
6874 int res4 = SWIG_TMPOBJ ;
6875
6876 arg1 = &temp1;
6877 arg2 = &temp2;
6878 arg3 = &temp3;
6879 arg4 = &temp4;
6880 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6881 {
6882 if (!wxPyCheckForApp()) SWIG_fail;
6883 PyThreadState* __tstate = wxPyBeginAllowThreads();
6884 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6885 wxPyEndAllowThreads(__tstate);
6886 if (PyErr_Occurred()) SWIG_fail;
6887 }
6888 resultobj = SWIG_Py_Void();
6889 if (SWIG_IsTmpObj(res1)) {
6890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6891 } else {
6892 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6894 }
6895 if (SWIG_IsTmpObj(res2)) {
6896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6897 } else {
6898 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6900 }
6901 if (SWIG_IsTmpObj(res3)) {
6902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6903 } else {
6904 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6906 }
6907 if (SWIG_IsTmpObj(res4)) {
6908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6909 } else {
6910 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6912 }
6913 return resultobj;
6914 fail:
6915 return NULL;
6916 }
6917
6918
6919 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6920 PyObject *resultobj = 0;
6921 wxRect result;
6922
6923 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6924 {
6925 if (!wxPyCheckForApp()) SWIG_fail;
6926 PyThreadState* __tstate = wxPyBeginAllowThreads();
6927 result = wxGetClientDisplayRect();
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6939 PyObject *resultobj = 0;
6940 wxCursor *arg1 = 0 ;
6941 void *argp1 = 0 ;
6942 int res1 = 0 ;
6943 PyObject * obj0 = 0 ;
6944 char * kwnames[] = {
6945 (char *) "cursor", NULL
6946 };
6947
6948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6949 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6950 if (!SWIG_IsOK(res1)) {
6951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6952 }
6953 if (!argp1) {
6954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6955 }
6956 arg1 = reinterpret_cast< wxCursor * >(argp1);
6957 {
6958 if (!wxPyCheckForApp()) SWIG_fail;
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 wxSetCursor(*arg1);
6961 wxPyEndAllowThreads(__tstate);
6962 if (PyErr_Occurred()) SWIG_fail;
6963 }
6964 resultobj = SWIG_Py_Void();
6965 return resultobj;
6966 fail:
6967 return NULL;
6968 }
6969
6970
6971 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6972 PyObject *resultobj = 0;
6973 void *result = 0 ;
6974
6975 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6976 {
6977 if (!wxPyCheckForApp()) SWIG_fail;
6978 PyThreadState* __tstate = wxPyBeginAllowThreads();
6979 result = (void *)wxGetXDisplay();
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj = 0;
6992 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6993 void *argp1 = 0 ;
6994 int res1 = 0 ;
6995 PyObject * obj0 = 0 ;
6996 char * kwnames[] = {
6997 (char *) "cursor", NULL
6998 };
6999
7000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
7001 if (obj0) {
7002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
7003 if (!SWIG_IsOK(res1)) {
7004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
7005 }
7006 arg1 = reinterpret_cast< wxCursor * >(argp1);
7007 }
7008 {
7009 if (!wxPyCheckForApp()) SWIG_fail;
7010 PyThreadState* __tstate = wxPyBeginAllowThreads();
7011 wxBeginBusyCursor(arg1);
7012 wxPyEndAllowThreads(__tstate);
7013 if (PyErr_Occurred()) SWIG_fail;
7014 }
7015 resultobj = SWIG_Py_Void();
7016 return resultobj;
7017 fail:
7018 return NULL;
7019 }
7020
7021
7022 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7023 PyObject *resultobj = 0;
7024 wxPoint result;
7025
7026 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
7027 {
7028 if (!wxPyCheckForApp()) SWIG_fail;
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 result = wxGetMousePosition();
7031 wxPyEndAllowThreads(__tstate);
7032 if (PyErr_Occurred()) SWIG_fail;
7033 }
7034 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7042 PyObject *resultobj = 0;
7043 wxWindow *result = 0 ;
7044
7045 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
7046 {
7047 if (!wxPyCheckForApp()) SWIG_fail;
7048 PyThreadState* __tstate = wxPyBeginAllowThreads();
7049 result = (wxWindow *)FindWindowAtPointer();
7050 wxPyEndAllowThreads(__tstate);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 {
7054 resultobj = wxPyMake_wxObject(result, 0);
7055 }
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7063 PyObject *resultobj = 0;
7064 wxWindow *result = 0 ;
7065
7066 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
7067 {
7068 if (!wxPyCheckForApp()) SWIG_fail;
7069 PyThreadState* __tstate = wxPyBeginAllowThreads();
7070 result = (wxWindow *)wxGetActiveWindow();
7071 wxPyEndAllowThreads(__tstate);
7072 if (PyErr_Occurred()) SWIG_fail;
7073 }
7074 {
7075 resultobj = wxPyMake_wxObject(result, 0);
7076 }
7077 return resultobj;
7078 fail:
7079 return NULL;
7080 }
7081
7082
7083 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj = 0;
7085 wxPoint *arg1 = 0 ;
7086 wxWindow *result = 0 ;
7087 wxPoint temp1 ;
7088 PyObject * obj0 = 0 ;
7089 char * kwnames[] = {
7090 (char *) "pt", NULL
7091 };
7092
7093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7094 {
7095 arg1 = &temp1;
7096 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7097 }
7098 {
7099 if (!wxPyCheckForApp()) SWIG_fail;
7100 PyThreadState* __tstate = wxPyBeginAllowThreads();
7101 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
7102 wxPyEndAllowThreads(__tstate);
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 {
7106 resultobj = wxPyMake_wxObject(result, 0);
7107 }
7108 return resultobj;
7109 fail:
7110 return NULL;
7111 }
7112
7113
7114 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7115 PyObject *resultobj = 0;
7116 wxPoint *arg1 = 0 ;
7117 wxWindow *result = 0 ;
7118 wxPoint temp1 ;
7119 PyObject * obj0 = 0 ;
7120 char * kwnames[] = {
7121 (char *) "pt", NULL
7122 };
7123
7124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
7125 {
7126 arg1 = &temp1;
7127 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7128 }
7129 {
7130 if (!wxPyCheckForApp()) SWIG_fail;
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 {
7137 resultobj = wxPyMake_wxObject(result, 0);
7138 }
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7146 PyObject *resultobj = 0;
7147 wxWindow *arg1 = (wxWindow *) 0 ;
7148 wxWindow *result = 0 ;
7149 void *argp1 = 0 ;
7150 int res1 = 0 ;
7151 PyObject * obj0 = 0 ;
7152 char * kwnames[] = {
7153 (char *) "win", NULL
7154 };
7155
7156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7158 if (!SWIG_IsOK(res1)) {
7159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7160 }
7161 arg1 = reinterpret_cast< wxWindow * >(argp1);
7162 {
7163 if (!wxPyCheckForApp()) SWIG_fail;
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 result = (wxWindow *)wxGetTopLevelParent(arg1);
7166 wxPyEndAllowThreads(__tstate);
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 {
7170 resultobj = wxPyMake_wxObject(result, 0);
7171 }
7172 return resultobj;
7173 fail:
7174 return NULL;
7175 }
7176
7177
7178 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7179 PyObject *resultobj = 0;
7180 wxString *arg1 = 0 ;
7181 bool result;
7182 bool temp1 = false ;
7183 PyObject * obj0 = 0 ;
7184 char * kwnames[] = {
7185 (char *) "url", NULL
7186 };
7187
7188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7189 {
7190 arg1 = wxString_in_helper(obj0);
7191 if (arg1 == NULL) SWIG_fail;
7192 temp1 = true;
7193 }
7194 {
7195 PyThreadState* __tstate = wxPyBeginAllowThreads();
7196 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7197 wxPyEndAllowThreads(__tstate);
7198 if (PyErr_Occurred()) SWIG_fail;
7199 }
7200 {
7201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7202 }
7203 {
7204 if (temp1)
7205 delete arg1;
7206 }
7207 return resultobj;
7208 fail:
7209 {
7210 if (temp1)
7211 delete arg1;
7212 }
7213 return NULL;
7214 }
7215
7216
7217 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7218 PyObject *resultobj = 0;
7219 wxKeyCode arg1 ;
7220 bool result;
7221 int val1 ;
7222 int ecode1 = 0 ;
7223 PyObject * obj0 = 0 ;
7224 char * kwnames[] = {
7225 (char *) "key", NULL
7226 };
7227
7228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7229 ecode1 = SWIG_AsVal_int(obj0, &val1);
7230 if (!SWIG_IsOK(ecode1)) {
7231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7232 }
7233 arg1 = static_cast< wxKeyCode >(val1);
7234 {
7235 if (!wxPyCheckForApp()) SWIG_fail;
7236 PyThreadState* __tstate = wxPyBeginAllowThreads();
7237 result = (bool)wxGetKeyState(arg1);
7238 wxPyEndAllowThreads(__tstate);
7239 if (PyErr_Occurred()) SWIG_fail;
7240 }
7241 {
7242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7243 }
7244 return resultobj;
7245 fail:
7246 return NULL;
7247 }
7248
7249
7250 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7251 PyObject *resultobj = 0;
7252 wxMouseState *result = 0 ;
7253
7254 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 result = (wxMouseState *)new wxMouseState();
7258 wxPyEndAllowThreads(__tstate);
7259 if (PyErr_Occurred()) SWIG_fail;
7260 }
7261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7262 return resultobj;
7263 fail:
7264 return NULL;
7265 }
7266
7267
7268 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7269 PyObject *resultobj = 0;
7270 wxMouseState *arg1 = (wxMouseState *) 0 ;
7271 void *argp1 = 0 ;
7272 int res1 = 0 ;
7273 PyObject *swig_obj[1] ;
7274
7275 if (!args) SWIG_fail;
7276 swig_obj[0] = args;
7277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7280 }
7281 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7282 {
7283 PyThreadState* __tstate = wxPyBeginAllowThreads();
7284 delete arg1;
7285
7286 wxPyEndAllowThreads(__tstate);
7287 if (PyErr_Occurred()) SWIG_fail;
7288 }
7289 resultobj = SWIG_Py_Void();
7290 return resultobj;
7291 fail:
7292 return NULL;
7293 }
7294
7295
7296 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7297 PyObject *resultobj = 0;
7298 wxMouseState *arg1 = (wxMouseState *) 0 ;
7299 int result;
7300 void *argp1 = 0 ;
7301 int res1 = 0 ;
7302 PyObject *swig_obj[1] ;
7303
7304 if (!args) SWIG_fail;
7305 swig_obj[0] = args;
7306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7307 if (!SWIG_IsOK(res1)) {
7308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7309 }
7310 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7311 {
7312 PyThreadState* __tstate = wxPyBeginAllowThreads();
7313 result = (int)(arg1)->GetX();
7314 wxPyEndAllowThreads(__tstate);
7315 if (PyErr_Occurred()) SWIG_fail;
7316 }
7317 resultobj = SWIG_From_int(static_cast< int >(result));
7318 return resultobj;
7319 fail:
7320 return NULL;
7321 }
7322
7323
7324 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7325 PyObject *resultobj = 0;
7326 wxMouseState *arg1 = (wxMouseState *) 0 ;
7327 int result;
7328 void *argp1 = 0 ;
7329 int res1 = 0 ;
7330 PyObject *swig_obj[1] ;
7331
7332 if (!args) SWIG_fail;
7333 swig_obj[0] = args;
7334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7335 if (!SWIG_IsOK(res1)) {
7336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7337 }
7338 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7339 {
7340 PyThreadState* __tstate = wxPyBeginAllowThreads();
7341 result = (int)(arg1)->GetY();
7342 wxPyEndAllowThreads(__tstate);
7343 if (PyErr_Occurred()) SWIG_fail;
7344 }
7345 resultobj = SWIG_From_int(static_cast< int >(result));
7346 return resultobj;
7347 fail:
7348 return NULL;
7349 }
7350
7351
7352 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7353 PyObject *resultobj = 0;
7354 wxMouseState *arg1 = (wxMouseState *) 0 ;
7355 bool result;
7356 void *argp1 = 0 ;
7357 int res1 = 0 ;
7358 PyObject *swig_obj[1] ;
7359
7360 if (!args) SWIG_fail;
7361 swig_obj[0] = args;
7362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7363 if (!SWIG_IsOK(res1)) {
7364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7365 }
7366 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7367 {
7368 PyThreadState* __tstate = wxPyBeginAllowThreads();
7369 result = (bool)(arg1)->LeftDown();
7370 wxPyEndAllowThreads(__tstate);
7371 if (PyErr_Occurred()) SWIG_fail;
7372 }
7373 {
7374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7375 }
7376 return resultobj;
7377 fail:
7378 return NULL;
7379 }
7380
7381
7382 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7383 PyObject *resultobj = 0;
7384 wxMouseState *arg1 = (wxMouseState *) 0 ;
7385 bool result;
7386 void *argp1 = 0 ;
7387 int res1 = 0 ;
7388 PyObject *swig_obj[1] ;
7389
7390 if (!args) SWIG_fail;
7391 swig_obj[0] = args;
7392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7393 if (!SWIG_IsOK(res1)) {
7394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7395 }
7396 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7397 {
7398 PyThreadState* __tstate = wxPyBeginAllowThreads();
7399 result = (bool)(arg1)->MiddleDown();
7400 wxPyEndAllowThreads(__tstate);
7401 if (PyErr_Occurred()) SWIG_fail;
7402 }
7403 {
7404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7405 }
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7413 PyObject *resultobj = 0;
7414 wxMouseState *arg1 = (wxMouseState *) 0 ;
7415 bool result;
7416 void *argp1 = 0 ;
7417 int res1 = 0 ;
7418 PyObject *swig_obj[1] ;
7419
7420 if (!args) SWIG_fail;
7421 swig_obj[0] = args;
7422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7423 if (!SWIG_IsOK(res1)) {
7424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7425 }
7426 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7427 {
7428 PyThreadState* __tstate = wxPyBeginAllowThreads();
7429 result = (bool)(arg1)->RightDown();
7430 wxPyEndAllowThreads(__tstate);
7431 if (PyErr_Occurred()) SWIG_fail;
7432 }
7433 {
7434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7435 }
7436 return resultobj;
7437 fail:
7438 return NULL;
7439 }
7440
7441
7442 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7443 PyObject *resultobj = 0;
7444 wxMouseState *arg1 = (wxMouseState *) 0 ;
7445 bool result;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 PyObject *swig_obj[1] ;
7449
7450 if (!args) SWIG_fail;
7451 swig_obj[0] = args;
7452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7453 if (!SWIG_IsOK(res1)) {
7454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7455 }
7456 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 result = (bool)(arg1)->ControlDown();
7460 wxPyEndAllowThreads(__tstate);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 {
7464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7465 }
7466 return resultobj;
7467 fail:
7468 return NULL;
7469 }
7470
7471
7472 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7473 PyObject *resultobj = 0;
7474 wxMouseState *arg1 = (wxMouseState *) 0 ;
7475 bool result;
7476 void *argp1 = 0 ;
7477 int res1 = 0 ;
7478 PyObject *swig_obj[1] ;
7479
7480 if (!args) SWIG_fail;
7481 swig_obj[0] = args;
7482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7485 }
7486 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (bool)(arg1)->ShiftDown();
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 {
7494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495 }
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7503 PyObject *resultobj = 0;
7504 wxMouseState *arg1 = (wxMouseState *) 0 ;
7505 bool result;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 PyObject *swig_obj[1] ;
7509
7510 if (!args) SWIG_fail;
7511 swig_obj[0] = args;
7512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7513 if (!SWIG_IsOK(res1)) {
7514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7515 }
7516 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (bool)(arg1)->AltDown();
7520 wxPyEndAllowThreads(__tstate);
7521 if (PyErr_Occurred()) SWIG_fail;
7522 }
7523 {
7524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7525 }
7526 return resultobj;
7527 fail:
7528 return NULL;
7529 }
7530
7531
7532 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7533 PyObject *resultobj = 0;
7534 wxMouseState *arg1 = (wxMouseState *) 0 ;
7535 bool result;
7536 void *argp1 = 0 ;
7537 int res1 = 0 ;
7538 PyObject *swig_obj[1] ;
7539
7540 if (!args) SWIG_fail;
7541 swig_obj[0] = args;
7542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7543 if (!SWIG_IsOK(res1)) {
7544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7545 }
7546 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7547 {
7548 PyThreadState* __tstate = wxPyBeginAllowThreads();
7549 result = (bool)(arg1)->MetaDown();
7550 wxPyEndAllowThreads(__tstate);
7551 if (PyErr_Occurred()) SWIG_fail;
7552 }
7553 {
7554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7555 }
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7563 PyObject *resultobj = 0;
7564 wxMouseState *arg1 = (wxMouseState *) 0 ;
7565 bool result;
7566 void *argp1 = 0 ;
7567 int res1 = 0 ;
7568 PyObject *swig_obj[1] ;
7569
7570 if (!args) SWIG_fail;
7571 swig_obj[0] = args;
7572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7573 if (!SWIG_IsOK(res1)) {
7574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7575 }
7576 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7577 {
7578 PyThreadState* __tstate = wxPyBeginAllowThreads();
7579 result = (bool)(arg1)->CmdDown();
7580 wxPyEndAllowThreads(__tstate);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 {
7584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7585 }
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7593 PyObject *resultobj = 0;
7594 wxMouseState *arg1 = (wxMouseState *) 0 ;
7595 int arg2 ;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 int val2 ;
7599 int ecode2 = 0 ;
7600 PyObject * obj0 = 0 ;
7601 PyObject * obj1 = 0 ;
7602 char * kwnames[] = {
7603 (char *) "self",(char *) "x", NULL
7604 };
7605
7606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7608 if (!SWIG_IsOK(res1)) {
7609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7610 }
7611 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7612 ecode2 = SWIG_AsVal_int(obj1, &val2);
7613 if (!SWIG_IsOK(ecode2)) {
7614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7615 }
7616 arg2 = static_cast< int >(val2);
7617 {
7618 PyThreadState* __tstate = wxPyBeginAllowThreads();
7619 (arg1)->SetX(arg2);
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 resultobj = SWIG_Py_Void();
7624 return resultobj;
7625 fail:
7626 return NULL;
7627 }
7628
7629
7630 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7631 PyObject *resultobj = 0;
7632 wxMouseState *arg1 = (wxMouseState *) 0 ;
7633 int arg2 ;
7634 void *argp1 = 0 ;
7635 int res1 = 0 ;
7636 int val2 ;
7637 int ecode2 = 0 ;
7638 PyObject * obj0 = 0 ;
7639 PyObject * obj1 = 0 ;
7640 char * kwnames[] = {
7641 (char *) "self",(char *) "y", NULL
7642 };
7643
7644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7646 if (!SWIG_IsOK(res1)) {
7647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7648 }
7649 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7650 ecode2 = SWIG_AsVal_int(obj1, &val2);
7651 if (!SWIG_IsOK(ecode2)) {
7652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7653 }
7654 arg2 = static_cast< int >(val2);
7655 {
7656 PyThreadState* __tstate = wxPyBeginAllowThreads();
7657 (arg1)->SetY(arg2);
7658 wxPyEndAllowThreads(__tstate);
7659 if (PyErr_Occurred()) SWIG_fail;
7660 }
7661 resultobj = SWIG_Py_Void();
7662 return resultobj;
7663 fail:
7664 return NULL;
7665 }
7666
7667
7668 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7669 PyObject *resultobj = 0;
7670 wxMouseState *arg1 = (wxMouseState *) 0 ;
7671 bool arg2 ;
7672 void *argp1 = 0 ;
7673 int res1 = 0 ;
7674 bool val2 ;
7675 int ecode2 = 0 ;
7676 PyObject * obj0 = 0 ;
7677 PyObject * obj1 = 0 ;
7678 char * kwnames[] = {
7679 (char *) "self",(char *) "down", NULL
7680 };
7681
7682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7686 }
7687 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7689 if (!SWIG_IsOK(ecode2)) {
7690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7691 }
7692 arg2 = static_cast< bool >(val2);
7693 {
7694 PyThreadState* __tstate = wxPyBeginAllowThreads();
7695 (arg1)->SetLeftDown(arg2);
7696 wxPyEndAllowThreads(__tstate);
7697 if (PyErr_Occurred()) SWIG_fail;
7698 }
7699 resultobj = SWIG_Py_Void();
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj = 0;
7708 wxMouseState *arg1 = (wxMouseState *) 0 ;
7709 bool arg2 ;
7710 void *argp1 = 0 ;
7711 int res1 = 0 ;
7712 bool val2 ;
7713 int ecode2 = 0 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 char * kwnames[] = {
7717 (char *) "self",(char *) "down", NULL
7718 };
7719
7720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7724 }
7725 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7726 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7727 if (!SWIG_IsOK(ecode2)) {
7728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7729 }
7730 arg2 = static_cast< bool >(val2);
7731 {
7732 PyThreadState* __tstate = wxPyBeginAllowThreads();
7733 (arg1)->SetMiddleDown(arg2);
7734 wxPyEndAllowThreads(__tstate);
7735 if (PyErr_Occurred()) SWIG_fail;
7736 }
7737 resultobj = SWIG_Py_Void();
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj = 0;
7746 wxMouseState *arg1 = (wxMouseState *) 0 ;
7747 bool arg2 ;
7748 void *argp1 = 0 ;
7749 int res1 = 0 ;
7750 bool val2 ;
7751 int ecode2 = 0 ;
7752 PyObject * obj0 = 0 ;
7753 PyObject * obj1 = 0 ;
7754 char * kwnames[] = {
7755 (char *) "self",(char *) "down", NULL
7756 };
7757
7758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7760 if (!SWIG_IsOK(res1)) {
7761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7762 }
7763 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7764 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7765 if (!SWIG_IsOK(ecode2)) {
7766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7767 }
7768 arg2 = static_cast< bool >(val2);
7769 {
7770 PyThreadState* __tstate = wxPyBeginAllowThreads();
7771 (arg1)->SetRightDown(arg2);
7772 wxPyEndAllowThreads(__tstate);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 resultobj = SWIG_Py_Void();
7776 return resultobj;
7777 fail:
7778 return NULL;
7779 }
7780
7781
7782 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7783 PyObject *resultobj = 0;
7784 wxMouseState *arg1 = (wxMouseState *) 0 ;
7785 bool arg2 ;
7786 void *argp1 = 0 ;
7787 int res1 = 0 ;
7788 bool val2 ;
7789 int ecode2 = 0 ;
7790 PyObject * obj0 = 0 ;
7791 PyObject * obj1 = 0 ;
7792 char * kwnames[] = {
7793 (char *) "self",(char *) "down", NULL
7794 };
7795
7796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7798 if (!SWIG_IsOK(res1)) {
7799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7800 }
7801 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7802 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7803 if (!SWIG_IsOK(ecode2)) {
7804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7805 }
7806 arg2 = static_cast< bool >(val2);
7807 {
7808 PyThreadState* __tstate = wxPyBeginAllowThreads();
7809 (arg1)->SetControlDown(arg2);
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 resultobj = SWIG_Py_Void();
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj = 0;
7822 wxMouseState *arg1 = (wxMouseState *) 0 ;
7823 bool arg2 ;
7824 void *argp1 = 0 ;
7825 int res1 = 0 ;
7826 bool val2 ;
7827 int ecode2 = 0 ;
7828 PyObject * obj0 = 0 ;
7829 PyObject * obj1 = 0 ;
7830 char * kwnames[] = {
7831 (char *) "self",(char *) "down", NULL
7832 };
7833
7834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7836 if (!SWIG_IsOK(res1)) {
7837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7838 }
7839 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7841 if (!SWIG_IsOK(ecode2)) {
7842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7843 }
7844 arg2 = static_cast< bool >(val2);
7845 {
7846 PyThreadState* __tstate = wxPyBeginAllowThreads();
7847 (arg1)->SetShiftDown(arg2);
7848 wxPyEndAllowThreads(__tstate);
7849 if (PyErr_Occurred()) SWIG_fail;
7850 }
7851 resultobj = SWIG_Py_Void();
7852 return resultobj;
7853 fail:
7854 return NULL;
7855 }
7856
7857
7858 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7859 PyObject *resultobj = 0;
7860 wxMouseState *arg1 = (wxMouseState *) 0 ;
7861 bool arg2 ;
7862 void *argp1 = 0 ;
7863 int res1 = 0 ;
7864 bool val2 ;
7865 int ecode2 = 0 ;
7866 PyObject * obj0 = 0 ;
7867 PyObject * obj1 = 0 ;
7868 char * kwnames[] = {
7869 (char *) "self",(char *) "down", NULL
7870 };
7871
7872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7874 if (!SWIG_IsOK(res1)) {
7875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7876 }
7877 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7878 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7879 if (!SWIG_IsOK(ecode2)) {
7880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7881 }
7882 arg2 = static_cast< bool >(val2);
7883 {
7884 PyThreadState* __tstate = wxPyBeginAllowThreads();
7885 (arg1)->SetAltDown(arg2);
7886 wxPyEndAllowThreads(__tstate);
7887 if (PyErr_Occurred()) SWIG_fail;
7888 }
7889 resultobj = SWIG_Py_Void();
7890 return resultobj;
7891 fail:
7892 return NULL;
7893 }
7894
7895
7896 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7897 PyObject *resultobj = 0;
7898 wxMouseState *arg1 = (wxMouseState *) 0 ;
7899 bool arg2 ;
7900 void *argp1 = 0 ;
7901 int res1 = 0 ;
7902 bool val2 ;
7903 int ecode2 = 0 ;
7904 PyObject * obj0 = 0 ;
7905 PyObject * obj1 = 0 ;
7906 char * kwnames[] = {
7907 (char *) "self",(char *) "down", NULL
7908 };
7909
7910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7912 if (!SWIG_IsOK(res1)) {
7913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7914 }
7915 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7916 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7917 if (!SWIG_IsOK(ecode2)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7919 }
7920 arg2 = static_cast< bool >(val2);
7921 {
7922 PyThreadState* __tstate = wxPyBeginAllowThreads();
7923 (arg1)->SetMetaDown(arg2);
7924 wxPyEndAllowThreads(__tstate);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 resultobj = SWIG_Py_Void();
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7935 PyObject *obj;
7936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7937 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7938 return SWIG_Py_Void();
7939 }
7940
7941 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7942 return SWIG_Python_InitShadowInstance(args);
7943 }
7944
7945 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7946 PyObject *resultobj = 0;
7947 wxMouseState result;
7948
7949 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7950 {
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 result = wxGetMouseState();
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *resultobj = 0;
7965
7966 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7967 {
7968 if (!wxPyCheckForApp()) SWIG_fail;
7969 PyThreadState* __tstate = wxPyBeginAllowThreads();
7970 wxWakeUpMainThread();
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 resultobj = SWIG_Py_Void();
7975 return resultobj;
7976 fail:
7977 return NULL;
7978 }
7979
7980
7981 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7982 PyObject *resultobj = 0;
7983
7984 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7985 {
7986 if (!wxPyCheckForApp()) SWIG_fail;
7987 PyThreadState* __tstate = wxPyBeginAllowThreads();
7988 wxMutexGuiEnter();
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 resultobj = SWIG_Py_Void();
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8000 PyObject *resultobj = 0;
8001
8002 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
8003 {
8004 if (!wxPyCheckForApp()) SWIG_fail;
8005 PyThreadState* __tstate = wxPyBeginAllowThreads();
8006 wxMutexGuiLeave();
8007 wxPyEndAllowThreads(__tstate);
8008 if (PyErr_Occurred()) SWIG_fail;
8009 }
8010 resultobj = SWIG_Py_Void();
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8018 PyObject *resultobj = 0;
8019 wxMutexGuiLocker *result = 0 ;
8020
8021 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
8022 {
8023 if (!wxPyCheckForApp()) SWIG_fail;
8024 PyThreadState* __tstate = wxPyBeginAllowThreads();
8025 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
8026 wxPyEndAllowThreads(__tstate);
8027 if (PyErr_Occurred()) SWIG_fail;
8028 }
8029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8037 PyObject *resultobj = 0;
8038 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
8039 void *argp1 = 0 ;
8040 int res1 = 0 ;
8041 PyObject *swig_obj[1] ;
8042
8043 if (!args) SWIG_fail;
8044 swig_obj[0] = args;
8045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
8046 if (!SWIG_IsOK(res1)) {
8047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
8048 }
8049 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
8050 {
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 delete arg1;
8053
8054 wxPyEndAllowThreads(__tstate);
8055 if (PyErr_Occurred()) SWIG_fail;
8056 }
8057 resultobj = SWIG_Py_Void();
8058 return resultobj;
8059 fail:
8060 return NULL;
8061 }
8062
8063
8064 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8065 PyObject *obj;
8066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8067 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
8068 return SWIG_Py_Void();
8069 }
8070
8071 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8072 return SWIG_Python_InitShadowInstance(args);
8073 }
8074
8075 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8076 PyObject *resultobj = 0;
8077 bool result;
8078
8079 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
8080 {
8081 PyThreadState* __tstate = wxPyBeginAllowThreads();
8082 result = (bool)wxThread_IsMain();
8083 wxPyEndAllowThreads(__tstate);
8084 if (PyErr_Occurred()) SWIG_fail;
8085 }
8086 {
8087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8088 }
8089 return resultobj;
8090 fail:
8091 return NULL;
8092 }
8093
8094
8095 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8096 PyObject *resultobj = 0;
8097 wxString *arg1 = 0 ;
8098 wxToolTip *result = 0 ;
8099 bool temp1 = false ;
8100 PyObject * obj0 = 0 ;
8101 char * kwnames[] = {
8102 (char *) "tip", NULL
8103 };
8104
8105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
8106 {
8107 arg1 = wxString_in_helper(obj0);
8108 if (arg1 == NULL) SWIG_fail;
8109 temp1 = true;
8110 }
8111 {
8112 if (!wxPyCheckForApp()) SWIG_fail;
8113 PyThreadState* __tstate = wxPyBeginAllowThreads();
8114 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
8115 wxPyEndAllowThreads(__tstate);
8116 if (PyErr_Occurred()) SWIG_fail;
8117 }
8118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
8119 {
8120 if (temp1)
8121 delete arg1;
8122 }
8123 return resultobj;
8124 fail:
8125 {
8126 if (temp1)
8127 delete arg1;
8128 }
8129 return NULL;
8130 }
8131
8132
8133 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8134 PyObject *resultobj = 0;
8135 wxToolTip *arg1 = (wxToolTip *) 0 ;
8136 void *argp1 = 0 ;
8137 int res1 = 0 ;
8138 PyObject *swig_obj[1] ;
8139
8140 if (!args) SWIG_fail;
8141 swig_obj[0] = args;
8142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
8143 if (!SWIG_IsOK(res1)) {
8144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8145 }
8146 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8147 {
8148 PyThreadState* __tstate = wxPyBeginAllowThreads();
8149 delete arg1;
8150
8151 wxPyEndAllowThreads(__tstate);
8152 if (PyErr_Occurred()) SWIG_fail;
8153 }
8154 resultobj = SWIG_Py_Void();
8155 return resultobj;
8156 fail:
8157 return NULL;
8158 }
8159
8160
8161 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8162 PyObject *resultobj = 0;
8163 wxToolTip *arg1 = (wxToolTip *) 0 ;
8164 wxString *arg2 = 0 ;
8165 void *argp1 = 0 ;
8166 int res1 = 0 ;
8167 bool temp2 = false ;
8168 PyObject * obj0 = 0 ;
8169 PyObject * obj1 = 0 ;
8170 char * kwnames[] = {
8171 (char *) "self",(char *) "tip", NULL
8172 };
8173
8174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8176 if (!SWIG_IsOK(res1)) {
8177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8178 }
8179 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8180 {
8181 arg2 = wxString_in_helper(obj1);
8182 if (arg2 == NULL) SWIG_fail;
8183 temp2 = true;
8184 }
8185 {
8186 PyThreadState* __tstate = wxPyBeginAllowThreads();
8187 (arg1)->SetTip((wxString const &)*arg2);
8188 wxPyEndAllowThreads(__tstate);
8189 if (PyErr_Occurred()) SWIG_fail;
8190 }
8191 resultobj = SWIG_Py_Void();
8192 {
8193 if (temp2)
8194 delete arg2;
8195 }
8196 return resultobj;
8197 fail:
8198 {
8199 if (temp2)
8200 delete arg2;
8201 }
8202 return NULL;
8203 }
8204
8205
8206 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8207 PyObject *resultobj = 0;
8208 wxToolTip *arg1 = (wxToolTip *) 0 ;
8209 wxString result;
8210 void *argp1 = 0 ;
8211 int res1 = 0 ;
8212 PyObject *swig_obj[1] ;
8213
8214 if (!args) SWIG_fail;
8215 swig_obj[0] = args;
8216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8217 if (!SWIG_IsOK(res1)) {
8218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8219 }
8220 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8221 {
8222 PyThreadState* __tstate = wxPyBeginAllowThreads();
8223 result = (arg1)->GetTip();
8224 wxPyEndAllowThreads(__tstate);
8225 if (PyErr_Occurred()) SWIG_fail;
8226 }
8227 {
8228 #if wxUSE_UNICODE
8229 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8230 #else
8231 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8232 #endif
8233 }
8234 return resultobj;
8235 fail:
8236 return NULL;
8237 }
8238
8239
8240 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8241 PyObject *resultobj = 0;
8242 wxToolTip *arg1 = (wxToolTip *) 0 ;
8243 wxWindow *result = 0 ;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 PyObject *swig_obj[1] ;
8247
8248 if (!args) SWIG_fail;
8249 swig_obj[0] = args;
8250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8251 if (!SWIG_IsOK(res1)) {
8252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8253 }
8254 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8255 {
8256 PyThreadState* __tstate = wxPyBeginAllowThreads();
8257 result = (wxWindow *)(arg1)->GetWindow();
8258 wxPyEndAllowThreads(__tstate);
8259 if (PyErr_Occurred()) SWIG_fail;
8260 }
8261 {
8262 resultobj = wxPyMake_wxObject(result, 0);
8263 }
8264 return resultobj;
8265 fail:
8266 return NULL;
8267 }
8268
8269
8270 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8271 PyObject *resultobj = 0;
8272 bool arg1 ;
8273 bool val1 ;
8274 int ecode1 = 0 ;
8275 PyObject * obj0 = 0 ;
8276 char * kwnames[] = {
8277 (char *) "flag", NULL
8278 };
8279
8280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8281 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8282 if (!SWIG_IsOK(ecode1)) {
8283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8284 }
8285 arg1 = static_cast< bool >(val1);
8286 {
8287 PyThreadState* __tstate = wxPyBeginAllowThreads();
8288 wxToolTip::Enable(arg1);
8289 wxPyEndAllowThreads(__tstate);
8290 if (PyErr_Occurred()) SWIG_fail;
8291 }
8292 resultobj = SWIG_Py_Void();
8293 return resultobj;
8294 fail:
8295 return NULL;
8296 }
8297
8298
8299 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8300 PyObject *resultobj = 0;
8301 long arg1 ;
8302 long val1 ;
8303 int ecode1 = 0 ;
8304 PyObject * obj0 = 0 ;
8305 char * kwnames[] = {
8306 (char *) "milliseconds", NULL
8307 };
8308
8309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8310 ecode1 = SWIG_AsVal_long(obj0, &val1);
8311 if (!SWIG_IsOK(ecode1)) {
8312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8313 }
8314 arg1 = static_cast< long >(val1);
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 wxToolTip::SetDelay(arg1);
8318 wxPyEndAllowThreads(__tstate);
8319 if (PyErr_Occurred()) SWIG_fail;
8320 }
8321 resultobj = SWIG_Py_Void();
8322 return resultobj;
8323 fail:
8324 return NULL;
8325 }
8326
8327
8328 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8329 PyObject *obj;
8330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8331 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8332 return SWIG_Py_Void();
8333 }
8334
8335 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8336 return SWIG_Python_InitShadowInstance(args);
8337 }
8338
8339 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxWindow *arg1 = (wxWindow *) 0 ;
8342 wxSize *arg2 = 0 ;
8343 wxCaret *result = 0 ;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 wxSize temp2 ;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 char * kwnames[] = {
8350 (char *) "window",(char *) "size", NULL
8351 };
8352
8353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8355 if (!SWIG_IsOK(res1)) {
8356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8357 }
8358 arg1 = reinterpret_cast< wxWindow * >(argp1);
8359 {
8360 arg2 = &temp2;
8361 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8362 }
8363 {
8364 if (!wxPyCheckForApp()) SWIG_fail;
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8367 wxPyEndAllowThreads(__tstate);
8368 if (PyErr_Occurred()) SWIG_fail;
8369 }
8370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8378 PyObject *resultobj = 0;
8379 wxCaret *arg1 = (wxCaret *) 0 ;
8380 void *argp1 = 0 ;
8381 int res1 = 0 ;
8382 PyObject *swig_obj[1] ;
8383
8384 if (!args) SWIG_fail;
8385 swig_obj[0] = args;
8386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8387 if (!SWIG_IsOK(res1)) {
8388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8389 }
8390 arg1 = reinterpret_cast< wxCaret * >(argp1);
8391 {
8392 PyThreadState* __tstate = wxPyBeginAllowThreads();
8393 delete arg1;
8394
8395 wxPyEndAllowThreads(__tstate);
8396 if (PyErr_Occurred()) SWIG_fail;
8397 }
8398 resultobj = SWIG_Py_Void();
8399 return resultobj;
8400 fail:
8401 return NULL;
8402 }
8403
8404
8405 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8406 PyObject *resultobj = 0;
8407 wxCaret *arg1 = (wxCaret *) 0 ;
8408 void *argp1 = 0 ;
8409 int res1 = 0 ;
8410 PyObject *swig_obj[1] ;
8411
8412 if (!args) SWIG_fail;
8413 swig_obj[0] = args;
8414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8415 if (!SWIG_IsOK(res1)) {
8416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8417 }
8418 arg1 = reinterpret_cast< wxCaret * >(argp1);
8419 {
8420 PyThreadState* __tstate = wxPyBeginAllowThreads();
8421 wxCaret_Destroy(arg1);
8422 wxPyEndAllowThreads(__tstate);
8423 if (PyErr_Occurred()) SWIG_fail;
8424 }
8425 resultobj = SWIG_Py_Void();
8426 return resultobj;
8427 fail:
8428 return NULL;
8429 }
8430
8431
8432 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8433 PyObject *resultobj = 0;
8434 wxCaret *arg1 = (wxCaret *) 0 ;
8435 bool result;
8436 void *argp1 = 0 ;
8437 int res1 = 0 ;
8438 PyObject *swig_obj[1] ;
8439
8440 if (!args) SWIG_fail;
8441 swig_obj[0] = args;
8442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8443 if (!SWIG_IsOK(res1)) {
8444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8445 }
8446 arg1 = reinterpret_cast< wxCaret * >(argp1);
8447 {
8448 PyThreadState* __tstate = wxPyBeginAllowThreads();
8449 result = (bool)(arg1)->IsOk();
8450 wxPyEndAllowThreads(__tstate);
8451 if (PyErr_Occurred()) SWIG_fail;
8452 }
8453 {
8454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8455 }
8456 return resultobj;
8457 fail:
8458 return NULL;
8459 }
8460
8461
8462 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8463 PyObject *resultobj = 0;
8464 wxCaret *arg1 = (wxCaret *) 0 ;
8465 bool result;
8466 void *argp1 = 0 ;
8467 int res1 = 0 ;
8468 PyObject *swig_obj[1] ;
8469
8470 if (!args) SWIG_fail;
8471 swig_obj[0] = args;
8472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8475 }
8476 arg1 = reinterpret_cast< wxCaret * >(argp1);
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 result = (bool)(arg1)->IsVisible();
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 {
8484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8485 }
8486 return resultobj;
8487 fail:
8488 return NULL;
8489 }
8490
8491
8492 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8493 PyObject *resultobj = 0;
8494 wxCaret *arg1 = (wxCaret *) 0 ;
8495 wxPoint result;
8496 void *argp1 = 0 ;
8497 int res1 = 0 ;
8498 PyObject *swig_obj[1] ;
8499
8500 if (!args) SWIG_fail;
8501 swig_obj[0] = args;
8502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8503 if (!SWIG_IsOK(res1)) {
8504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8505 }
8506 arg1 = reinterpret_cast< wxCaret * >(argp1);
8507 {
8508 PyThreadState* __tstate = wxPyBeginAllowThreads();
8509 result = (arg1)->GetPosition();
8510 wxPyEndAllowThreads(__tstate);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8514 return resultobj;
8515 fail:
8516 return NULL;
8517 }
8518
8519
8520 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8521 PyObject *resultobj = 0;
8522 wxCaret *arg1 = (wxCaret *) 0 ;
8523 int *arg2 = (int *) 0 ;
8524 int *arg3 = (int *) 0 ;
8525 void *argp1 = 0 ;
8526 int res1 = 0 ;
8527 int temp2 ;
8528 int res2 = SWIG_TMPOBJ ;
8529 int temp3 ;
8530 int res3 = SWIG_TMPOBJ ;
8531 PyObject *swig_obj[1] ;
8532
8533 arg2 = &temp2;
8534 arg3 = &temp3;
8535 if (!args) SWIG_fail;
8536 swig_obj[0] = args;
8537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8538 if (!SWIG_IsOK(res1)) {
8539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8540 }
8541 arg1 = reinterpret_cast< wxCaret * >(argp1);
8542 {
8543 PyThreadState* __tstate = wxPyBeginAllowThreads();
8544 (arg1)->GetPosition(arg2,arg3);
8545 wxPyEndAllowThreads(__tstate);
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_Py_Void();
8549 if (SWIG_IsTmpObj(res2)) {
8550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8551 } else {
8552 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8554 }
8555 if (SWIG_IsTmpObj(res3)) {
8556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8557 } else {
8558 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8560 }
8561 return resultobj;
8562 fail:
8563 return NULL;
8564 }
8565
8566
8567 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8568 PyObject *resultobj = 0;
8569 wxCaret *arg1 = (wxCaret *) 0 ;
8570 wxSize result;
8571 void *argp1 = 0 ;
8572 int res1 = 0 ;
8573 PyObject *swig_obj[1] ;
8574
8575 if (!args) SWIG_fail;
8576 swig_obj[0] = args;
8577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8578 if (!SWIG_IsOK(res1)) {
8579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8580 }
8581 arg1 = reinterpret_cast< wxCaret * >(argp1);
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 result = (arg1)->GetSize();
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8596 PyObject *resultobj = 0;
8597 wxCaret *arg1 = (wxCaret *) 0 ;
8598 int *arg2 = (int *) 0 ;
8599 int *arg3 = (int *) 0 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 int temp2 ;
8603 int res2 = SWIG_TMPOBJ ;
8604 int temp3 ;
8605 int res3 = SWIG_TMPOBJ ;
8606 PyObject *swig_obj[1] ;
8607
8608 arg2 = &temp2;
8609 arg3 = &temp3;
8610 if (!args) SWIG_fail;
8611 swig_obj[0] = args;
8612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8613 if (!SWIG_IsOK(res1)) {
8614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8615 }
8616 arg1 = reinterpret_cast< wxCaret * >(argp1);
8617 {
8618 PyThreadState* __tstate = wxPyBeginAllowThreads();
8619 (arg1)->GetSize(arg2,arg3);
8620 wxPyEndAllowThreads(__tstate);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 resultobj = SWIG_Py_Void();
8624 if (SWIG_IsTmpObj(res2)) {
8625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8626 } else {
8627 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8629 }
8630 if (SWIG_IsTmpObj(res3)) {
8631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8632 } else {
8633 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8634 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8635 }
8636 return resultobj;
8637 fail:
8638 return NULL;
8639 }
8640
8641
8642 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8643 PyObject *resultobj = 0;
8644 wxCaret *arg1 = (wxCaret *) 0 ;
8645 wxWindow *result = 0 ;
8646 void *argp1 = 0 ;
8647 int res1 = 0 ;
8648 PyObject *swig_obj[1] ;
8649
8650 if (!args) SWIG_fail;
8651 swig_obj[0] = args;
8652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8653 if (!SWIG_IsOK(res1)) {
8654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8655 }
8656 arg1 = reinterpret_cast< wxCaret * >(argp1);
8657 {
8658 PyThreadState* __tstate = wxPyBeginAllowThreads();
8659 result = (wxWindow *)(arg1)->GetWindow();
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 {
8664 resultobj = wxPyMake_wxObject(result, 0);
8665 }
8666 return resultobj;
8667 fail:
8668 return NULL;
8669 }
8670
8671
8672 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8673 PyObject *resultobj = 0;
8674 wxCaret *arg1 = (wxCaret *) 0 ;
8675 int arg2 ;
8676 int arg3 ;
8677 void *argp1 = 0 ;
8678 int res1 = 0 ;
8679 int val2 ;
8680 int ecode2 = 0 ;
8681 int val3 ;
8682 int ecode3 = 0 ;
8683 PyObject * obj0 = 0 ;
8684 PyObject * obj1 = 0 ;
8685 PyObject * obj2 = 0 ;
8686 char * kwnames[] = {
8687 (char *) "self",(char *) "x",(char *) "y", NULL
8688 };
8689
8690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8692 if (!SWIG_IsOK(res1)) {
8693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8694 }
8695 arg1 = reinterpret_cast< wxCaret * >(argp1);
8696 ecode2 = SWIG_AsVal_int(obj1, &val2);
8697 if (!SWIG_IsOK(ecode2)) {
8698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8699 }
8700 arg2 = static_cast< int >(val2);
8701 ecode3 = SWIG_AsVal_int(obj2, &val3);
8702 if (!SWIG_IsOK(ecode3)) {
8703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8704 }
8705 arg3 = static_cast< int >(val3);
8706 {
8707 PyThreadState* __tstate = wxPyBeginAllowThreads();
8708 (arg1)->Move(arg2,arg3);
8709 wxPyEndAllowThreads(__tstate);
8710 if (PyErr_Occurred()) SWIG_fail;
8711 }
8712 resultobj = SWIG_Py_Void();
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj = 0;
8721 wxCaret *arg1 = (wxCaret *) 0 ;
8722 wxPoint *arg2 = 0 ;
8723 void *argp1 = 0 ;
8724 int res1 = 0 ;
8725 wxPoint temp2 ;
8726 PyObject * obj0 = 0 ;
8727 PyObject * obj1 = 0 ;
8728 char * kwnames[] = {
8729 (char *) "self",(char *) "pt", NULL
8730 };
8731
8732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8734 if (!SWIG_IsOK(res1)) {
8735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8736 }
8737 arg1 = reinterpret_cast< wxCaret * >(argp1);
8738 {
8739 arg2 = &temp2;
8740 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8741 }
8742 {
8743 PyThreadState* __tstate = wxPyBeginAllowThreads();
8744 (arg1)->Move((wxPoint const &)*arg2);
8745 wxPyEndAllowThreads(__tstate);
8746 if (PyErr_Occurred()) SWIG_fail;
8747 }
8748 resultobj = SWIG_Py_Void();
8749 return resultobj;
8750 fail:
8751 return NULL;
8752 }
8753
8754
8755 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8756 PyObject *resultobj = 0;
8757 wxCaret *arg1 = (wxCaret *) 0 ;
8758 int arg2 ;
8759 int arg3 ;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 int val2 ;
8763 int ecode2 = 0 ;
8764 int val3 ;
8765 int ecode3 = 0 ;
8766 PyObject * obj0 = 0 ;
8767 PyObject * obj1 = 0 ;
8768 PyObject * obj2 = 0 ;
8769 char * kwnames[] = {
8770 (char *) "self",(char *) "width",(char *) "height", NULL
8771 };
8772
8773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8775 if (!SWIG_IsOK(res1)) {
8776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8777 }
8778 arg1 = reinterpret_cast< wxCaret * >(argp1);
8779 ecode2 = SWIG_AsVal_int(obj1, &val2);
8780 if (!SWIG_IsOK(ecode2)) {
8781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8782 }
8783 arg2 = static_cast< int >(val2);
8784 ecode3 = SWIG_AsVal_int(obj2, &val3);
8785 if (!SWIG_IsOK(ecode3)) {
8786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8787 }
8788 arg3 = static_cast< int >(val3);
8789 {
8790 PyThreadState* __tstate = wxPyBeginAllowThreads();
8791 (arg1)->SetSize(arg2,arg3);
8792 wxPyEndAllowThreads(__tstate);
8793 if (PyErr_Occurred()) SWIG_fail;
8794 }
8795 resultobj = SWIG_Py_Void();
8796 return resultobj;
8797 fail:
8798 return NULL;
8799 }
8800
8801
8802 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8803 PyObject *resultobj = 0;
8804 wxCaret *arg1 = (wxCaret *) 0 ;
8805 wxSize *arg2 = 0 ;
8806 void *argp1 = 0 ;
8807 int res1 = 0 ;
8808 wxSize temp2 ;
8809 PyObject * obj0 = 0 ;
8810 PyObject * obj1 = 0 ;
8811 char * kwnames[] = {
8812 (char *) "self",(char *) "size", NULL
8813 };
8814
8815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8817 if (!SWIG_IsOK(res1)) {
8818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8819 }
8820 arg1 = reinterpret_cast< wxCaret * >(argp1);
8821 {
8822 arg2 = &temp2;
8823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8824 }
8825 {
8826 PyThreadState* __tstate = wxPyBeginAllowThreads();
8827 (arg1)->SetSize((wxSize const &)*arg2);
8828 wxPyEndAllowThreads(__tstate);
8829 if (PyErr_Occurred()) SWIG_fail;
8830 }
8831 resultobj = SWIG_Py_Void();
8832 return resultobj;
8833 fail:
8834 return NULL;
8835 }
8836
8837
8838 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj = 0;
8840 wxCaret *arg1 = (wxCaret *) 0 ;
8841 int arg2 = (int) true ;
8842 void *argp1 = 0 ;
8843 int res1 = 0 ;
8844 int val2 ;
8845 int ecode2 = 0 ;
8846 PyObject * obj0 = 0 ;
8847 PyObject * obj1 = 0 ;
8848 char * kwnames[] = {
8849 (char *) "self",(char *) "show", NULL
8850 };
8851
8852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8854 if (!SWIG_IsOK(res1)) {
8855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8856 }
8857 arg1 = reinterpret_cast< wxCaret * >(argp1);
8858 if (obj1) {
8859 ecode2 = SWIG_AsVal_int(obj1, &val2);
8860 if (!SWIG_IsOK(ecode2)) {
8861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8862 }
8863 arg2 = static_cast< int >(val2);
8864 }
8865 {
8866 PyThreadState* __tstate = wxPyBeginAllowThreads();
8867 (arg1)->Show(arg2);
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 resultobj = SWIG_Py_Void();
8872 return resultobj;
8873 fail:
8874 return NULL;
8875 }
8876
8877
8878 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8879 PyObject *resultobj = 0;
8880 wxCaret *arg1 = (wxCaret *) 0 ;
8881 void *argp1 = 0 ;
8882 int res1 = 0 ;
8883 PyObject *swig_obj[1] ;
8884
8885 if (!args) SWIG_fail;
8886 swig_obj[0] = args;
8887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8888 if (!SWIG_IsOK(res1)) {
8889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8890 }
8891 arg1 = reinterpret_cast< wxCaret * >(argp1);
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 (arg1)->Hide();
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 resultobj = SWIG_Py_Void();
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8906 PyObject *resultobj = 0;
8907 int result;
8908
8909 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8910 {
8911 PyThreadState* __tstate = wxPyBeginAllowThreads();
8912 result = (int)wxCaret::GetBlinkTime();
8913 wxPyEndAllowThreads(__tstate);
8914 if (PyErr_Occurred()) SWIG_fail;
8915 }
8916 resultobj = SWIG_From_int(static_cast< int >(result));
8917 return resultobj;
8918 fail:
8919 return NULL;
8920 }
8921
8922
8923 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj = 0;
8925 int arg1 ;
8926 int val1 ;
8927 int ecode1 = 0 ;
8928 PyObject * obj0 = 0 ;
8929 char * kwnames[] = {
8930 (char *) "milliseconds", NULL
8931 };
8932
8933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8934 ecode1 = SWIG_AsVal_int(obj0, &val1);
8935 if (!SWIG_IsOK(ecode1)) {
8936 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8937 }
8938 arg1 = static_cast< int >(val1);
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 wxCaret::SetBlinkTime(arg1);
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 resultobj = SWIG_Py_Void();
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8953 PyObject *obj;
8954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8955 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8956 return SWIG_Py_Void();
8957 }
8958
8959 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8960 return SWIG_Python_InitShadowInstance(args);
8961 }
8962
8963 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8964 PyObject *resultobj = 0;
8965 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8966 wxBusyCursor *result = 0 ;
8967 void *argp1 = 0 ;
8968 int res1 = 0 ;
8969 PyObject * obj0 = 0 ;
8970 char * kwnames[] = {
8971 (char *) "cursor", NULL
8972 };
8973
8974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8975 if (obj0) {
8976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8977 if (!SWIG_IsOK(res1)) {
8978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8979 }
8980 arg1 = reinterpret_cast< wxCursor * >(argp1);
8981 }
8982 {
8983 if (!wxPyCheckForApp()) SWIG_fail;
8984 PyThreadState* __tstate = wxPyBeginAllowThreads();
8985 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8990 return resultobj;
8991 fail:
8992 return NULL;
8993 }
8994
8995
8996 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8997 PyObject *resultobj = 0;
8998 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8999 void *argp1 = 0 ;
9000 int res1 = 0 ;
9001 PyObject *swig_obj[1] ;
9002
9003 if (!args) SWIG_fail;
9004 swig_obj[0] = args;
9005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
9006 if (!SWIG_IsOK(res1)) {
9007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
9008 }
9009 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 delete arg1;
9013
9014 wxPyEndAllowThreads(__tstate);
9015 if (PyErr_Occurred()) SWIG_fail;
9016 }
9017 resultobj = SWIG_Py_Void();
9018 return resultobj;
9019 fail:
9020 return NULL;
9021 }
9022
9023
9024 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9025 PyObject *obj;
9026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9027 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
9028 return SWIG_Py_Void();
9029 }
9030
9031 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9032 return SWIG_Python_InitShadowInstance(args);
9033 }
9034
9035 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9036 PyObject *resultobj = 0;
9037 wxWindow *arg1 = (wxWindow *) NULL ;
9038 wxWindowDisabler *result = 0 ;
9039 void *argp1 = 0 ;
9040 int res1 = 0 ;
9041 PyObject * obj0 = 0 ;
9042 char * kwnames[] = {
9043 (char *) "winToSkip", NULL
9044 };
9045
9046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
9047 if (obj0) {
9048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9049 if (!SWIG_IsOK(res1)) {
9050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
9051 }
9052 arg1 = reinterpret_cast< wxWindow * >(argp1);
9053 }
9054 {
9055 if (!wxPyCheckForApp()) SWIG_fail;
9056 PyThreadState* __tstate = wxPyBeginAllowThreads();
9057 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
9058 wxPyEndAllowThreads(__tstate);
9059 if (PyErr_Occurred()) SWIG_fail;
9060 }
9061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
9062 return resultobj;
9063 fail:
9064 return NULL;
9065 }
9066
9067
9068 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9069 PyObject *resultobj = 0;
9070 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
9071 void *argp1 = 0 ;
9072 int res1 = 0 ;
9073 PyObject *swig_obj[1] ;
9074
9075 if (!args) SWIG_fail;
9076 swig_obj[0] = args;
9077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
9078 if (!SWIG_IsOK(res1)) {
9079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
9080 }
9081 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
9082 {
9083 PyThreadState* __tstate = wxPyBeginAllowThreads();
9084 delete arg1;
9085
9086 wxPyEndAllowThreads(__tstate);
9087 if (PyErr_Occurred()) SWIG_fail;
9088 }
9089 resultobj = SWIG_Py_Void();
9090 return resultobj;
9091 fail:
9092 return NULL;
9093 }
9094
9095
9096 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9097 PyObject *obj;
9098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9099 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
9100 return SWIG_Py_Void();
9101 }
9102
9103 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 return SWIG_Python_InitShadowInstance(args);
9105 }
9106
9107 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9108 PyObject *resultobj = 0;
9109 wxString *arg1 = 0 ;
9110 wxBusyInfo *result = 0 ;
9111 bool temp1 = false ;
9112 PyObject * obj0 = 0 ;
9113 char * kwnames[] = {
9114 (char *) "message", NULL
9115 };
9116
9117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
9118 {
9119 arg1 = wxString_in_helper(obj0);
9120 if (arg1 == NULL) SWIG_fail;
9121 temp1 = true;
9122 }
9123 {
9124 if (!wxPyCheckForApp()) SWIG_fail;
9125 PyThreadState* __tstate = wxPyBeginAllowThreads();
9126 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
9131 {
9132 if (temp1)
9133 delete arg1;
9134 }
9135 return resultobj;
9136 fail:
9137 {
9138 if (temp1)
9139 delete arg1;
9140 }
9141 return NULL;
9142 }
9143
9144
9145 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9146 PyObject *resultobj = 0;
9147 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
9148 void *argp1 = 0 ;
9149 int res1 = 0 ;
9150 PyObject *swig_obj[1] ;
9151
9152 if (!args) SWIG_fail;
9153 swig_obj[0] = args;
9154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9155 if (!SWIG_IsOK(res1)) {
9156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9157 }
9158 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9159 {
9160 PyThreadState* __tstate = wxPyBeginAllowThreads();
9161 delete arg1;
9162
9163 wxPyEndAllowThreads(__tstate);
9164 if (PyErr_Occurred()) SWIG_fail;
9165 }
9166 resultobj = SWIG_Py_Void();
9167 return resultobj;
9168 fail:
9169 return NULL;
9170 }
9171
9172
9173 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9174 PyObject *obj;
9175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9176 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9177 return SWIG_Py_Void();
9178 }
9179
9180 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9181 return SWIG_Python_InitShadowInstance(args);
9182 }
9183
9184 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9185 PyObject *resultobj = 0;
9186 wxStopWatch *result = 0 ;
9187
9188 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (wxStopWatch *)new wxStopWatch();
9192 wxPyEndAllowThreads(__tstate);
9193 if (PyErr_Occurred()) SWIG_fail;
9194 }
9195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9196 return resultobj;
9197 fail:
9198 return NULL;
9199 }
9200
9201
9202 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9203 PyObject *resultobj = 0;
9204 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9205 long arg2 = (long) 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 long val2 ;
9209 int ecode2 = 0 ;
9210 PyObject * obj0 = 0 ;
9211 PyObject * obj1 = 0 ;
9212 char * kwnames[] = {
9213 (char *) "self",(char *) "t0", NULL
9214 };
9215
9216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9218 if (!SWIG_IsOK(res1)) {
9219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9220 }
9221 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9222 if (obj1) {
9223 ecode2 = SWIG_AsVal_long(obj1, &val2);
9224 if (!SWIG_IsOK(ecode2)) {
9225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9226 }
9227 arg2 = static_cast< long >(val2);
9228 }
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 (arg1)->Start(arg2);
9232 wxPyEndAllowThreads(__tstate);
9233 if (PyErr_Occurred()) SWIG_fail;
9234 }
9235 resultobj = SWIG_Py_Void();
9236 return resultobj;
9237 fail:
9238 return NULL;
9239 }
9240
9241
9242 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9243 PyObject *resultobj = 0;
9244 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9245 void *argp1 = 0 ;
9246 int res1 = 0 ;
9247 PyObject *swig_obj[1] ;
9248
9249 if (!args) SWIG_fail;
9250 swig_obj[0] = args;
9251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9252 if (!SWIG_IsOK(res1)) {
9253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9254 }
9255 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9256 {
9257 PyThreadState* __tstate = wxPyBeginAllowThreads();
9258 (arg1)->Pause();
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 resultobj = SWIG_Py_Void();
9263 return resultobj;
9264 fail:
9265 return NULL;
9266 }
9267
9268
9269 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9270 PyObject *resultobj = 0;
9271 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9272 void *argp1 = 0 ;
9273 int res1 = 0 ;
9274 PyObject *swig_obj[1] ;
9275
9276 if (!args) SWIG_fail;
9277 swig_obj[0] = args;
9278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9279 if (!SWIG_IsOK(res1)) {
9280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9281 }
9282 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 (arg1)->Resume();
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_Py_Void();
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9297 PyObject *resultobj = 0;
9298 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9299 long result;
9300 void *argp1 = 0 ;
9301 int res1 = 0 ;
9302 PyObject *swig_obj[1] ;
9303
9304 if (!args) SWIG_fail;
9305 swig_obj[0] = args;
9306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9307 if (!SWIG_IsOK(res1)) {
9308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9309 }
9310 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 result = (long)((wxStopWatch const *)arg1)->Time();
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_From_long(static_cast< long >(result));
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9325 PyObject *obj;
9326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9327 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9328 return SWIG_Py_Void();
9329 }
9330
9331 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 return SWIG_Python_InitShadowInstance(args);
9333 }
9334
9335 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9336 PyObject *resultobj = 0;
9337 int arg1 = (int) 9 ;
9338 int arg2 = (int) wxID_FILE1 ;
9339 wxFileHistory *result = 0 ;
9340 int val1 ;
9341 int ecode1 = 0 ;
9342 int val2 ;
9343 int ecode2 = 0 ;
9344 PyObject * obj0 = 0 ;
9345 PyObject * obj1 = 0 ;
9346 char * kwnames[] = {
9347 (char *) "maxFiles",(char *) "idBase", NULL
9348 };
9349
9350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9351 if (obj0) {
9352 ecode1 = SWIG_AsVal_int(obj0, &val1);
9353 if (!SWIG_IsOK(ecode1)) {
9354 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9355 }
9356 arg1 = static_cast< int >(val1);
9357 }
9358 if (obj1) {
9359 ecode2 = SWIG_AsVal_int(obj1, &val2);
9360 if (!SWIG_IsOK(ecode2)) {
9361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9362 }
9363 arg2 = static_cast< int >(val2);
9364 }
9365 {
9366 PyThreadState* __tstate = wxPyBeginAllowThreads();
9367 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9368 wxPyEndAllowThreads(__tstate);
9369 if (PyErr_Occurred()) SWIG_fail;
9370 }
9371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9372 return resultobj;
9373 fail:
9374 return NULL;
9375 }
9376
9377
9378 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9379 PyObject *resultobj = 0;
9380 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9381 void *argp1 = 0 ;
9382 int res1 = 0 ;
9383 PyObject *swig_obj[1] ;
9384
9385 if (!args) SWIG_fail;
9386 swig_obj[0] = args;
9387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9388 if (!SWIG_IsOK(res1)) {
9389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9390 }
9391 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9392 {
9393 PyThreadState* __tstate = wxPyBeginAllowThreads();
9394 delete arg1;
9395
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 resultobj = SWIG_Py_Void();
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj = 0;
9408 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9409 wxString *arg2 = 0 ;
9410 void *argp1 = 0 ;
9411 int res1 = 0 ;
9412 bool temp2 = false ;
9413 PyObject * obj0 = 0 ;
9414 PyObject * obj1 = 0 ;
9415 char * kwnames[] = {
9416 (char *) "self",(char *) "file", NULL
9417 };
9418
9419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9421 if (!SWIG_IsOK(res1)) {
9422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9423 }
9424 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9425 {
9426 arg2 = wxString_in_helper(obj1);
9427 if (arg2 == NULL) SWIG_fail;
9428 temp2 = true;
9429 }
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 (arg1)->AddFileToHistory((wxString const &)*arg2);
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 resultobj = SWIG_Py_Void();
9437 {
9438 if (temp2)
9439 delete arg2;
9440 }
9441 return resultobj;
9442 fail:
9443 {
9444 if (temp2)
9445 delete arg2;
9446 }
9447 return NULL;
9448 }
9449
9450
9451 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9452 PyObject *resultobj = 0;
9453 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9454 int arg2 ;
9455 void *argp1 = 0 ;
9456 int res1 = 0 ;
9457 int val2 ;
9458 int ecode2 = 0 ;
9459 PyObject * obj0 = 0 ;
9460 PyObject * obj1 = 0 ;
9461 char * kwnames[] = {
9462 (char *) "self",(char *) "i", NULL
9463 };
9464
9465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9467 if (!SWIG_IsOK(res1)) {
9468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9469 }
9470 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9471 ecode2 = SWIG_AsVal_int(obj1, &val2);
9472 if (!SWIG_IsOK(ecode2)) {
9473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9474 }
9475 arg2 = static_cast< int >(val2);
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 (arg1)->RemoveFileFromHistory(arg2);
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_Py_Void();
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9490 PyObject *resultobj = 0;
9491 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9492 int result;
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, 0 | 0 );
9500 if (!SWIG_IsOK(res1)) {
9501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9502 }
9503 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9507 wxPyEndAllowThreads(__tstate);
9508 if (PyErr_Occurred()) SWIG_fail;
9509 }
9510 resultobj = SWIG_From_int(static_cast< int >(result));
9511 return resultobj;
9512 fail:
9513 return NULL;
9514 }
9515
9516
9517 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj = 0;
9519 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9520 wxMenu *arg2 = (wxMenu *) 0 ;
9521 void *argp1 = 0 ;
9522 int res1 = 0 ;
9523 void *argp2 = 0 ;
9524 int res2 = 0 ;
9525 PyObject * obj0 = 0 ;
9526 PyObject * obj1 = 0 ;
9527 char * kwnames[] = {
9528 (char *) "self",(char *) "menu", NULL
9529 };
9530
9531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",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_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9535 }
9536 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9537 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9538 if (!SWIG_IsOK(res2)) {
9539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9540 }
9541 arg2 = reinterpret_cast< wxMenu * >(argp2);
9542 {
9543 PyThreadState* __tstate = wxPyBeginAllowThreads();
9544 (arg1)->UseMenu(arg2);
9545 wxPyEndAllowThreads(__tstate);
9546 if (PyErr_Occurred()) SWIG_fail;
9547 }
9548 resultobj = SWIG_Py_Void();
9549 return resultobj;
9550 fail:
9551 return NULL;
9552 }
9553
9554
9555 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9556 PyObject *resultobj = 0;
9557 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9558 wxMenu *arg2 = (wxMenu *) 0 ;
9559 void *argp1 = 0 ;
9560 int res1 = 0 ;
9561 void *argp2 = 0 ;
9562 int res2 = 0 ;
9563 PyObject * obj0 = 0 ;
9564 PyObject * obj1 = 0 ;
9565 char * kwnames[] = {
9566 (char *) "self",(char *) "menu", NULL
9567 };
9568
9569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9571 if (!SWIG_IsOK(res1)) {
9572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9573 }
9574 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9576 if (!SWIG_IsOK(res2)) {
9577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9578 }
9579 arg2 = reinterpret_cast< wxMenu * >(argp2);
9580 {
9581 PyThreadState* __tstate = wxPyBeginAllowThreads();
9582 (arg1)->RemoveMenu(arg2);
9583 wxPyEndAllowThreads(__tstate);
9584 if (PyErr_Occurred()) SWIG_fail;
9585 }
9586 resultobj = SWIG_Py_Void();
9587 return resultobj;
9588 fail:
9589 return NULL;
9590 }
9591
9592
9593 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9594 PyObject *resultobj = 0;
9595 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9596 wxConfigBase *arg2 = 0 ;
9597 void *argp1 = 0 ;
9598 int res1 = 0 ;
9599 void *argp2 = 0 ;
9600 int res2 = 0 ;
9601 PyObject * obj0 = 0 ;
9602 PyObject * obj1 = 0 ;
9603 char * kwnames[] = {
9604 (char *) "self",(char *) "config", NULL
9605 };
9606
9607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9609 if (!SWIG_IsOK(res1)) {
9610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9611 }
9612 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9613 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9614 if (!SWIG_IsOK(res2)) {
9615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9616 }
9617 if (!argp2) {
9618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9619 }
9620 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9621 {
9622 PyThreadState* __tstate = wxPyBeginAllowThreads();
9623 (arg1)->Load(*arg2);
9624 wxPyEndAllowThreads(__tstate);
9625 if (PyErr_Occurred()) SWIG_fail;
9626 }
9627 resultobj = SWIG_Py_Void();
9628 return resultobj;
9629 fail:
9630 return NULL;
9631 }
9632
9633
9634 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9635 PyObject *resultobj = 0;
9636 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9637 wxConfigBase *arg2 = 0 ;
9638 void *argp1 = 0 ;
9639 int res1 = 0 ;
9640 void *argp2 = 0 ;
9641 int res2 = 0 ;
9642 PyObject * obj0 = 0 ;
9643 PyObject * obj1 = 0 ;
9644 char * kwnames[] = {
9645 (char *) "self",(char *) "config", NULL
9646 };
9647
9648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9650 if (!SWIG_IsOK(res1)) {
9651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9652 }
9653 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9654 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9655 if (!SWIG_IsOK(res2)) {
9656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9657 }
9658 if (!argp2) {
9659 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9660 }
9661 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9662 {
9663 PyThreadState* __tstate = wxPyBeginAllowThreads();
9664 (arg1)->Save(*arg2);
9665 wxPyEndAllowThreads(__tstate);
9666 if (PyErr_Occurred()) SWIG_fail;
9667 }
9668 resultobj = SWIG_Py_Void();
9669 return resultobj;
9670 fail:
9671 return NULL;
9672 }
9673
9674
9675 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9676 PyObject *resultobj = 0;
9677 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9678 void *argp1 = 0 ;
9679 int res1 = 0 ;
9680 PyObject *swig_obj[1] ;
9681
9682 if (!args) SWIG_fail;
9683 swig_obj[0] = args;
9684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9685 if (!SWIG_IsOK(res1)) {
9686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9687 }
9688 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9689 {
9690 PyThreadState* __tstate = wxPyBeginAllowThreads();
9691 (arg1)->AddFilesToMenu();
9692 wxPyEndAllowThreads(__tstate);
9693 if (PyErr_Occurred()) SWIG_fail;
9694 }
9695 resultobj = SWIG_Py_Void();
9696 return resultobj;
9697 fail:
9698 return NULL;
9699 }
9700
9701
9702 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj = 0;
9704 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9705 wxMenu *arg2 = (wxMenu *) 0 ;
9706 void *argp1 = 0 ;
9707 int res1 = 0 ;
9708 void *argp2 = 0 ;
9709 int res2 = 0 ;
9710 PyObject * obj0 = 0 ;
9711 PyObject * obj1 = 0 ;
9712 char * kwnames[] = {
9713 (char *) "self",(char *) "menu", NULL
9714 };
9715
9716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9718 if (!SWIG_IsOK(res1)) {
9719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9720 }
9721 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9722 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9723 if (!SWIG_IsOK(res2)) {
9724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9725 }
9726 arg2 = reinterpret_cast< wxMenu * >(argp2);
9727 {
9728 PyThreadState* __tstate = wxPyBeginAllowThreads();
9729 (arg1)->AddFilesToMenu(arg2);
9730 wxPyEndAllowThreads(__tstate);
9731 if (PyErr_Occurred()) SWIG_fail;
9732 }
9733 resultobj = SWIG_Py_Void();
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj = 0;
9742 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9743 int arg2 ;
9744 wxString result;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 int val2 ;
9748 int ecode2 = 0 ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 char * kwnames[] = {
9752 (char *) "self",(char *) "i", NULL
9753 };
9754
9755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9757 if (!SWIG_IsOK(res1)) {
9758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9759 }
9760 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9761 ecode2 = SWIG_AsVal_int(obj1, &val2);
9762 if (!SWIG_IsOK(ecode2)) {
9763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9764 }
9765 arg2 = static_cast< int >(val2);
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 {
9773 #if wxUSE_UNICODE
9774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9775 #else
9776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9777 #endif
9778 }
9779 return resultobj;
9780 fail:
9781 return NULL;
9782 }
9783
9784
9785 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9786 PyObject *resultobj = 0;
9787 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9788 int result;
9789 void *argp1 = 0 ;
9790 int res1 = 0 ;
9791 PyObject *swig_obj[1] ;
9792
9793 if (!args) SWIG_fail;
9794 swig_obj[0] = args;
9795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9796 if (!SWIG_IsOK(res1)) {
9797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9798 }
9799 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 result = (int)((wxFileHistory const *)arg1)->GetCount();
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 resultobj = SWIG_From_int(static_cast< int >(result));
9807 return resultobj;
9808 fail:
9809 return NULL;
9810 }
9811
9812
9813 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9814 PyObject *obj;
9815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9816 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9817 return SWIG_Py_Void();
9818 }
9819
9820 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9821 return SWIG_Python_InitShadowInstance(args);
9822 }
9823
9824 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj = 0;
9826 wxString *arg1 = 0 ;
9827 wxString const &arg2_defvalue = wxPyEmptyString ;
9828 wxString *arg2 = (wxString *) &arg2_defvalue ;
9829 wxSingleInstanceChecker *result = 0 ;
9830 bool temp1 = false ;
9831 bool temp2 = false ;
9832 PyObject * obj0 = 0 ;
9833 PyObject * obj1 = 0 ;
9834 char * kwnames[] = {
9835 (char *) "name",(char *) "path", NULL
9836 };
9837
9838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9839 {
9840 arg1 = wxString_in_helper(obj0);
9841 if (arg1 == NULL) SWIG_fail;
9842 temp1 = true;
9843 }
9844 if (obj1) {
9845 {
9846 arg2 = wxString_in_helper(obj1);
9847 if (arg2 == NULL) SWIG_fail;
9848 temp2 = true;
9849 }
9850 }
9851 {
9852 PyThreadState* __tstate = wxPyBeginAllowThreads();
9853 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9854 wxPyEndAllowThreads(__tstate);
9855 if (PyErr_Occurred()) SWIG_fail;
9856 }
9857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9858 {
9859 if (temp1)
9860 delete arg1;
9861 }
9862 {
9863 if (temp2)
9864 delete arg2;
9865 }
9866 return resultobj;
9867 fail:
9868 {
9869 if (temp1)
9870 delete arg1;
9871 }
9872 {
9873 if (temp2)
9874 delete arg2;
9875 }
9876 return NULL;
9877 }
9878
9879
9880 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9881 PyObject *resultobj = 0;
9882 wxSingleInstanceChecker *result = 0 ;
9883
9884 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9885 {
9886 PyThreadState* __tstate = wxPyBeginAllowThreads();
9887 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9888 wxPyEndAllowThreads(__tstate);
9889 if (PyErr_Occurred()) SWIG_fail;
9890 }
9891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9892 return resultobj;
9893 fail:
9894 return NULL;
9895 }
9896
9897
9898 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9899 PyObject *resultobj = 0;
9900 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
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_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9908 if (!SWIG_IsOK(res1)) {
9909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9910 }
9911 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 delete arg1;
9915
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 resultobj = SWIG_Py_Void();
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9927 PyObject *resultobj = 0;
9928 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9929 wxString *arg2 = 0 ;
9930 wxString const &arg3_defvalue = wxPyEmptyString ;
9931 wxString *arg3 = (wxString *) &arg3_defvalue ;
9932 bool result;
9933 void *argp1 = 0 ;
9934 int res1 = 0 ;
9935 bool temp2 = false ;
9936 bool temp3 = false ;
9937 PyObject * obj0 = 0 ;
9938 PyObject * obj1 = 0 ;
9939 PyObject * obj2 = 0 ;
9940 char * kwnames[] = {
9941 (char *) "self",(char *) "name",(char *) "path", NULL
9942 };
9943
9944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9946 if (!SWIG_IsOK(res1)) {
9947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9948 }
9949 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9950 {
9951 arg2 = wxString_in_helper(obj1);
9952 if (arg2 == NULL) SWIG_fail;
9953 temp2 = true;
9954 }
9955 if (obj2) {
9956 {
9957 arg3 = wxString_in_helper(obj2);
9958 if (arg3 == NULL) SWIG_fail;
9959 temp3 = true;
9960 }
9961 }
9962 {
9963 PyThreadState* __tstate = wxPyBeginAllowThreads();
9964 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9965 wxPyEndAllowThreads(__tstate);
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 {
9969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9970 }
9971 {
9972 if (temp2)
9973 delete arg2;
9974 }
9975 {
9976 if (temp3)
9977 delete arg3;
9978 }
9979 return resultobj;
9980 fail:
9981 {
9982 if (temp2)
9983 delete arg2;
9984 }
9985 {
9986 if (temp3)
9987 delete arg3;
9988 }
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9994 PyObject *resultobj = 0;
9995 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9996 bool result;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 PyObject *swig_obj[1] ;
10000
10001 if (!args) SWIG_fail;
10002 swig_obj[0] = args;
10003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
10004 if (!SWIG_IsOK(res1)) {
10005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
10006 }
10007 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
10008 {
10009 PyThreadState* __tstate = wxPyBeginAllowThreads();
10010 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
10011 wxPyEndAllowThreads(__tstate);
10012 if (PyErr_Occurred()) SWIG_fail;
10013 }
10014 {
10015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10016 }
10017 return resultobj;
10018 fail:
10019 return NULL;
10020 }
10021
10022
10023 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10024 PyObject *obj;
10025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10026 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
10027 return SWIG_Py_Void();
10028 }
10029
10030 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10031 return SWIG_Python_InitShadowInstance(args);
10032 }
10033
10034 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10035 PyObject *resultobj = 0;
10036 wxWindow *arg1 = (wxWindow *) 0 ;
10037 wxDC *arg2 = 0 ;
10038 bool result;
10039 void *argp1 = 0 ;
10040 int res1 = 0 ;
10041 void *argp2 = 0 ;
10042 int res2 = 0 ;
10043 PyObject * obj0 = 0 ;
10044 PyObject * obj1 = 0 ;
10045 char * kwnames[] = {
10046 (char *) "window",(char *) "dc", NULL
10047 };
10048
10049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
10050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10051 if (!SWIG_IsOK(res1)) {
10052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
10053 }
10054 arg1 = reinterpret_cast< wxWindow * >(argp1);
10055 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
10056 if (!SWIG_IsOK(res2)) {
10057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10058 }
10059 if (!argp2) {
10060 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
10061 }
10062 arg2 = reinterpret_cast< wxDC * >(argp2);
10063 {
10064 PyThreadState* __tstate = wxPyBeginAllowThreads();
10065 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
10066 wxPyEndAllowThreads(__tstate);
10067 if (PyErr_Occurred()) SWIG_fail;
10068 }
10069 {
10070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10071 }
10072 return resultobj;
10073 fail:
10074 return NULL;
10075 }
10076
10077
10078 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10079 PyObject *resultobj = 0;
10080 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10081 void *argp1 = 0 ;
10082 int res1 = 0 ;
10083 PyObject *swig_obj[1] ;
10084
10085 if (!args) SWIG_fail;
10086 swig_obj[0] = args;
10087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
10088 if (!SWIG_IsOK(res1)) {
10089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10090 }
10091 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10092 {
10093 PyThreadState* __tstate = wxPyBeginAllowThreads();
10094 delete arg1;
10095
10096 wxPyEndAllowThreads(__tstate);
10097 if (PyErr_Occurred()) SWIG_fail;
10098 }
10099 resultobj = SWIG_Py_Void();
10100 return resultobj;
10101 fail:
10102 return NULL;
10103 }
10104
10105
10106 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10107 PyObject *resultobj = 0;
10108 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10109 wxString result;
10110 void *argp1 = 0 ;
10111 int res1 = 0 ;
10112 PyObject *swig_obj[1] ;
10113
10114 if (!args) SWIG_fail;
10115 swig_obj[0] = args;
10116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10117 if (!SWIG_IsOK(res1)) {
10118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10119 }
10120 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10121 {
10122 PyThreadState* __tstate = wxPyBeginAllowThreads();
10123 result = (arg1)->GetTip();
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 {
10128 #if wxUSE_UNICODE
10129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10130 #else
10131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10132 #endif
10133 }
10134 return resultobj;
10135 fail:
10136 return NULL;
10137 }
10138
10139
10140 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10141 PyObject *resultobj = 0;
10142 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10143 size_t result;
10144 void *argp1 = 0 ;
10145 int res1 = 0 ;
10146 PyObject *swig_obj[1] ;
10147
10148 if (!args) SWIG_fail;
10149 swig_obj[0] = args;
10150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10151 if (!SWIG_IsOK(res1)) {
10152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10153 }
10154 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10155 {
10156 PyThreadState* __tstate = wxPyBeginAllowThreads();
10157 result = (size_t)(arg1)->GetCurrentTip();
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10162 return resultobj;
10163 fail:
10164 return NULL;
10165 }
10166
10167
10168 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10169 PyObject *resultobj = 0;
10170 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10171 wxString *arg2 = 0 ;
10172 wxString result;
10173 void *argp1 = 0 ;
10174 int res1 = 0 ;
10175 bool temp2 = false ;
10176 PyObject * obj0 = 0 ;
10177 PyObject * obj1 = 0 ;
10178 char * kwnames[] = {
10179 (char *) "self",(char *) "tip", NULL
10180 };
10181
10182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10184 if (!SWIG_IsOK(res1)) {
10185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10186 }
10187 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10188 {
10189 arg2 = wxString_in_helper(obj1);
10190 if (arg2 == NULL) SWIG_fail;
10191 temp2 = true;
10192 }
10193 {
10194 PyThreadState* __tstate = wxPyBeginAllowThreads();
10195 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10196 wxPyEndAllowThreads(__tstate);
10197 if (PyErr_Occurred()) SWIG_fail;
10198 }
10199 {
10200 #if wxUSE_UNICODE
10201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10202 #else
10203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10204 #endif
10205 }
10206 {
10207 if (temp2)
10208 delete arg2;
10209 }
10210 return resultobj;
10211 fail:
10212 {
10213 if (temp2)
10214 delete arg2;
10215 }
10216 return NULL;
10217 }
10218
10219
10220 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10221 PyObject *obj;
10222 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10223 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10224 return SWIG_Py_Void();
10225 }
10226
10227 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10228 PyObject *resultobj = 0;
10229 size_t arg1 ;
10230 wxPyTipProvider *result = 0 ;
10231 size_t val1 ;
10232 int ecode1 = 0 ;
10233 PyObject * obj0 = 0 ;
10234 char * kwnames[] = {
10235 (char *) "currentTip", NULL
10236 };
10237
10238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10239 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10240 if (!SWIG_IsOK(ecode1)) {
10241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10242 }
10243 arg1 = static_cast< size_t >(val1);
10244 {
10245 PyThreadState* __tstate = wxPyBeginAllowThreads();
10246 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10247 wxPyEndAllowThreads(__tstate);
10248 if (PyErr_Occurred()) SWIG_fail;
10249 }
10250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10258 PyObject *resultobj = 0;
10259 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10260 PyObject *arg2 = (PyObject *) 0 ;
10261 PyObject *arg3 = (PyObject *) 0 ;
10262 void *argp1 = 0 ;
10263 int res1 = 0 ;
10264 PyObject * obj0 = 0 ;
10265 PyObject * obj1 = 0 ;
10266 PyObject * obj2 = 0 ;
10267 char * kwnames[] = {
10268 (char *) "self",(char *) "self",(char *) "_class", NULL
10269 };
10270
10271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10273 if (!SWIG_IsOK(res1)) {
10274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10275 }
10276 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10277 arg2 = obj1;
10278 arg3 = obj2;
10279 {
10280 PyThreadState* __tstate = wxPyBeginAllowThreads();
10281 (arg1)->_setCallbackInfo(arg2,arg3);
10282 wxPyEndAllowThreads(__tstate);
10283 if (PyErr_Occurred()) SWIG_fail;
10284 }
10285 resultobj = SWIG_Py_Void();
10286 return resultobj;
10287 fail:
10288 return NULL;
10289 }
10290
10291
10292 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10293 PyObject *obj;
10294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10295 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10296 return SWIG_Py_Void();
10297 }
10298
10299 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10300 return SWIG_Python_InitShadowInstance(args);
10301 }
10302
10303 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10304 PyObject *resultobj = 0;
10305 wxWindow *arg1 = (wxWindow *) 0 ;
10306 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10307 bool arg3 = (bool) true ;
10308 bool result;
10309 void *argp1 = 0 ;
10310 int res1 = 0 ;
10311 void *argp2 = 0 ;
10312 int res2 = 0 ;
10313 bool val3 ;
10314 int ecode3 = 0 ;
10315 PyObject * obj0 = 0 ;
10316 PyObject * obj1 = 0 ;
10317 PyObject * obj2 = 0 ;
10318 char * kwnames[] = {
10319 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10320 };
10321
10322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10324 if (!SWIG_IsOK(res1)) {
10325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10326 }
10327 arg1 = reinterpret_cast< wxWindow * >(argp1);
10328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10329 if (!SWIG_IsOK(res2)) {
10330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10331 }
10332 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10333 if (obj2) {
10334 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10335 if (!SWIG_IsOK(ecode3)) {
10336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10337 }
10338 arg3 = static_cast< bool >(val3);
10339 }
10340 {
10341 if (!wxPyCheckForApp()) SWIG_fail;
10342 PyThreadState* __tstate = wxPyBeginAllowThreads();
10343 result = (bool)wxShowTip(arg1,arg2,arg3);
10344 wxPyEndAllowThreads(__tstate);
10345 if (PyErr_Occurred()) SWIG_fail;
10346 }
10347 {
10348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10349 }
10350 return resultobj;
10351 fail:
10352 return NULL;
10353 }
10354
10355
10356 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10357 PyObject *resultobj = 0;
10358 wxString *arg1 = 0 ;
10359 size_t arg2 ;
10360 wxTipProvider *result = 0 ;
10361 bool temp1 = false ;
10362 size_t val2 ;
10363 int ecode2 = 0 ;
10364 PyObject * obj0 = 0 ;
10365 PyObject * obj1 = 0 ;
10366 char * kwnames[] = {
10367 (char *) "filename",(char *) "currentTip", NULL
10368 };
10369
10370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10371 {
10372 arg1 = wxString_in_helper(obj0);
10373 if (arg1 == NULL) SWIG_fail;
10374 temp1 = true;
10375 }
10376 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10377 if (!SWIG_IsOK(ecode2)) {
10378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10379 }
10380 arg2 = static_cast< size_t >(val2);
10381 {
10382 if (!wxPyCheckForApp()) SWIG_fail;
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10385 wxPyEndAllowThreads(__tstate);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10389 {
10390 if (temp1)
10391 delete arg1;
10392 }
10393 return resultobj;
10394 fail:
10395 {
10396 if (temp1)
10397 delete arg1;
10398 }
10399 return NULL;
10400 }
10401
10402
10403 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10404 PyObject *resultobj = 0;
10405 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10406 int arg2 = (int) wxID_ANY ;
10407 wxPyTimer *result = 0 ;
10408 void *argp1 = 0 ;
10409 int res1 = 0 ;
10410 int val2 ;
10411 int ecode2 = 0 ;
10412 PyObject * obj0 = 0 ;
10413 PyObject * obj1 = 0 ;
10414 char * kwnames[] = {
10415 (char *) "owner",(char *) "id", NULL
10416 };
10417
10418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10419 if (obj0) {
10420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10423 }
10424 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10425 }
10426 if (obj1) {
10427 ecode2 = SWIG_AsVal_int(obj1, &val2);
10428 if (!SWIG_IsOK(ecode2)) {
10429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10430 }
10431 arg2 = static_cast< int >(val2);
10432 }
10433 {
10434 if (!wxPyCheckForApp()) SWIG_fail;
10435 PyThreadState* __tstate = wxPyBeginAllowThreads();
10436 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10441 return resultobj;
10442 fail:
10443 return NULL;
10444 }
10445
10446
10447 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10448 PyObject *resultobj = 0;
10449 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10450 void *argp1 = 0 ;
10451 int res1 = 0 ;
10452 PyObject *swig_obj[1] ;
10453
10454 if (!args) SWIG_fail;
10455 swig_obj[0] = args;
10456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10457 if (!SWIG_IsOK(res1)) {
10458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10459 }
10460 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10461 {
10462 PyThreadState* __tstate = wxPyBeginAllowThreads();
10463 delete arg1;
10464
10465 wxPyEndAllowThreads(__tstate);
10466 if (PyErr_Occurred()) SWIG_fail;
10467 }
10468 resultobj = SWIG_Py_Void();
10469 return resultobj;
10470 fail:
10471 return NULL;
10472 }
10473
10474
10475 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10476 PyObject *resultobj = 0;
10477 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10478 PyObject *arg2 = (PyObject *) 0 ;
10479 PyObject *arg3 = (PyObject *) 0 ;
10480 int arg4 = (int) 1 ;
10481 void *argp1 = 0 ;
10482 int res1 = 0 ;
10483 int val4 ;
10484 int ecode4 = 0 ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487 PyObject * obj2 = 0 ;
10488 PyObject * obj3 = 0 ;
10489 char * kwnames[] = {
10490 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10491 };
10492
10493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10497 }
10498 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10499 arg2 = obj1;
10500 arg3 = obj2;
10501 if (obj3) {
10502 ecode4 = SWIG_AsVal_int(obj3, &val4);
10503 if (!SWIG_IsOK(ecode4)) {
10504 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10505 }
10506 arg4 = static_cast< int >(val4);
10507 }
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10511 wxPyEndAllowThreads(__tstate);
10512 if (PyErr_Occurred()) SWIG_fail;
10513 }
10514 resultobj = SWIG_Py_Void();
10515 return resultobj;
10516 fail:
10517 return NULL;
10518 }
10519
10520
10521 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10522 PyObject *resultobj = 0;
10523 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10524 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10525 int arg3 = (int) wxID_ANY ;
10526 void *argp1 = 0 ;
10527 int res1 = 0 ;
10528 void *argp2 = 0 ;
10529 int res2 = 0 ;
10530 int val3 ;
10531 int ecode3 = 0 ;
10532 PyObject * obj0 = 0 ;
10533 PyObject * obj1 = 0 ;
10534 PyObject * obj2 = 0 ;
10535 char * kwnames[] = {
10536 (char *) "self",(char *) "owner",(char *) "id", NULL
10537 };
10538
10539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10541 if (!SWIG_IsOK(res1)) {
10542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10543 }
10544 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10546 if (!SWIG_IsOK(res2)) {
10547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10548 }
10549 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10550 if (obj2) {
10551 ecode3 = SWIG_AsVal_int(obj2, &val3);
10552 if (!SWIG_IsOK(ecode3)) {
10553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10554 }
10555 arg3 = static_cast< int >(val3);
10556 }
10557 {
10558 PyThreadState* __tstate = wxPyBeginAllowThreads();
10559 (arg1)->SetOwner(arg2,arg3);
10560 wxPyEndAllowThreads(__tstate);
10561 if (PyErr_Occurred()) SWIG_fail;
10562 }
10563 resultobj = SWIG_Py_Void();
10564 return resultobj;
10565 fail:
10566 return NULL;
10567 }
10568
10569
10570 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10571 PyObject *resultobj = 0;
10572 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10573 wxEvtHandler *result = 0 ;
10574 void *argp1 = 0 ;
10575 int res1 = 0 ;
10576 PyObject *swig_obj[1] ;
10577
10578 if (!args) SWIG_fail;
10579 swig_obj[0] = args;
10580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10581 if (!SWIG_IsOK(res1)) {
10582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10583 }
10584 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10585 {
10586 PyThreadState* __tstate = wxPyBeginAllowThreads();
10587 result = (wxEvtHandler *)(arg1)->GetOwner();
10588 wxPyEndAllowThreads(__tstate);
10589 if (PyErr_Occurred()) SWIG_fail;
10590 }
10591 {
10592 resultobj = wxPyMake_wxObject(result, 0);
10593 }
10594 return resultobj;
10595 fail:
10596 return NULL;
10597 }
10598
10599
10600 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10601 PyObject *resultobj = 0;
10602 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10603 int arg2 = (int) -1 ;
10604 bool arg3 = (bool) false ;
10605 bool result;
10606 void *argp1 = 0 ;
10607 int res1 = 0 ;
10608 int val2 ;
10609 int ecode2 = 0 ;
10610 bool val3 ;
10611 int ecode3 = 0 ;
10612 PyObject * obj0 = 0 ;
10613 PyObject * obj1 = 0 ;
10614 PyObject * obj2 = 0 ;
10615 char * kwnames[] = {
10616 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10617 };
10618
10619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10621 if (!SWIG_IsOK(res1)) {
10622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10623 }
10624 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10625 if (obj1) {
10626 ecode2 = SWIG_AsVal_int(obj1, &val2);
10627 if (!SWIG_IsOK(ecode2)) {
10628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10629 }
10630 arg2 = static_cast< int >(val2);
10631 }
10632 if (obj2) {
10633 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10634 if (!SWIG_IsOK(ecode3)) {
10635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10636 }
10637 arg3 = static_cast< bool >(val3);
10638 }
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (bool)(arg1)->Start(arg2,arg3);
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 {
10646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10647 }
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10655 PyObject *resultobj = 0;
10656 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10657 void *argp1 = 0 ;
10658 int res1 = 0 ;
10659 PyObject *swig_obj[1] ;
10660
10661 if (!args) SWIG_fail;
10662 swig_obj[0] = args;
10663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10664 if (!SWIG_IsOK(res1)) {
10665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10666 }
10667 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 (arg1)->Stop();
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 resultobj = SWIG_Py_Void();
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10682 PyObject *resultobj = 0;
10683 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10684 void *argp1 = 0 ;
10685 int res1 = 0 ;
10686 PyObject *swig_obj[1] ;
10687
10688 if (!args) SWIG_fail;
10689 swig_obj[0] = args;
10690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10691 if (!SWIG_IsOK(res1)) {
10692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10693 }
10694 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10695 {
10696 PyThreadState* __tstate = wxPyBeginAllowThreads();
10697 (arg1)->Notify();
10698 wxPyEndAllowThreads(__tstate);
10699 if (PyErr_Occurred()) SWIG_fail;
10700 }
10701 resultobj = SWIG_Py_Void();
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10709 PyObject *resultobj = 0;
10710 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10711 bool 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_wxPyTimer, 0 | 0 );
10719 if (!SWIG_IsOK(res1)) {
10720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10721 }
10722 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10723 {
10724 PyThreadState* __tstate = wxPyBeginAllowThreads();
10725 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 {
10730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10731 }
10732 return resultobj;
10733 fail:
10734 return NULL;
10735 }
10736
10737
10738 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10739 PyObject *resultobj = 0;
10740 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10741 int result;
10742 void *argp1 = 0 ;
10743 int res1 = 0 ;
10744 PyObject *swig_obj[1] ;
10745
10746 if (!args) SWIG_fail;
10747 swig_obj[0] = args;
10748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10751 }
10752 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10753 {
10754 PyThreadState* __tstate = wxPyBeginAllowThreads();
10755 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10756 wxPyEndAllowThreads(__tstate);
10757 if (PyErr_Occurred()) SWIG_fail;
10758 }
10759 resultobj = SWIG_From_int(static_cast< int >(result));
10760 return resultobj;
10761 fail:
10762 return NULL;
10763 }
10764
10765
10766 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10767 PyObject *resultobj = 0;
10768 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10769 int result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 PyObject *swig_obj[1] ;
10773
10774 if (!args) SWIG_fail;
10775 swig_obj[0] = args;
10776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10777 if (!SWIG_IsOK(res1)) {
10778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10779 }
10780 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10781 {
10782 PyThreadState* __tstate = wxPyBeginAllowThreads();
10783 result = (int)((wxPyTimer const *)arg1)->GetId();
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 resultobj = SWIG_From_int(static_cast< int >(result));
10788 return resultobj;
10789 fail:
10790 return NULL;
10791 }
10792
10793
10794 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10795 PyObject *resultobj = 0;
10796 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10797 bool result;
10798 void *argp1 = 0 ;
10799 int res1 = 0 ;
10800 PyObject *swig_obj[1] ;
10801
10802 if (!args) SWIG_fail;
10803 swig_obj[0] = args;
10804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10805 if (!SWIG_IsOK(res1)) {
10806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10807 }
10808 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10809 {
10810 PyThreadState* __tstate = wxPyBeginAllowThreads();
10811 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10812 wxPyEndAllowThreads(__tstate);
10813 if (PyErr_Occurred()) SWIG_fail;
10814 }
10815 {
10816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10817 }
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10825 PyObject *obj;
10826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10827 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10828 return SWIG_Py_Void();
10829 }
10830
10831 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10832 return SWIG_Python_InitShadowInstance(args);
10833 }
10834
10835 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10836 PyObject *resultobj = 0;
10837 int arg1 = (int) 0 ;
10838 int arg2 = (int) 0 ;
10839 wxTimerEvent *result = 0 ;
10840 int val1 ;
10841 int ecode1 = 0 ;
10842 int val2 ;
10843 int ecode2 = 0 ;
10844 PyObject * obj0 = 0 ;
10845 PyObject * obj1 = 0 ;
10846 char * kwnames[] = {
10847 (char *) "timerid",(char *) "interval", NULL
10848 };
10849
10850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10851 if (obj0) {
10852 ecode1 = SWIG_AsVal_int(obj0, &val1);
10853 if (!SWIG_IsOK(ecode1)) {
10854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10855 }
10856 arg1 = static_cast< int >(val1);
10857 }
10858 if (obj1) {
10859 ecode2 = SWIG_AsVal_int(obj1, &val2);
10860 if (!SWIG_IsOK(ecode2)) {
10861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10862 }
10863 arg2 = static_cast< int >(val2);
10864 }
10865 {
10866 PyThreadState* __tstate = wxPyBeginAllowThreads();
10867 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10868 wxPyEndAllowThreads(__tstate);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10879 PyObject *resultobj = 0;
10880 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10881 int result;
10882 void *argp1 = 0 ;
10883 int res1 = 0 ;
10884 PyObject *swig_obj[1] ;
10885
10886 if (!args) SWIG_fail;
10887 swig_obj[0] = args;
10888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10889 if (!SWIG_IsOK(res1)) {
10890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10891 }
10892 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10893 {
10894 PyThreadState* __tstate = wxPyBeginAllowThreads();
10895 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_From_int(static_cast< int >(result));
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10907 PyObject *obj;
10908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10909 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10910 return SWIG_Py_Void();
10911 }
10912
10913 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10914 return SWIG_Python_InitShadowInstance(args);
10915 }
10916
10917 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10918 PyObject *resultobj = 0;
10919 wxTimer *arg1 = 0 ;
10920 wxTimerRunner *result = 0 ;
10921 void *argp1 = 0 ;
10922 int res1 = 0 ;
10923
10924 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10926 if (!SWIG_IsOK(res1)) {
10927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10928 }
10929 if (!argp1) {
10930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10931 }
10932 arg1 = reinterpret_cast< wxTimer * >(argp1);
10933 {
10934 if (!wxPyCheckForApp()) SWIG_fail;
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10948 PyObject *resultobj = 0;
10949 wxTimer *arg1 = 0 ;
10950 int arg2 ;
10951 bool arg3 = (bool) false ;
10952 wxTimerRunner *result = 0 ;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 int val2 ;
10956 int ecode2 = 0 ;
10957 bool val3 ;
10958 int ecode3 = 0 ;
10959
10960 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10962 if (!SWIG_IsOK(res1)) {
10963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10964 }
10965 if (!argp1) {
10966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10967 }
10968 arg1 = reinterpret_cast< wxTimer * >(argp1);
10969 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10970 if (!SWIG_IsOK(ecode2)) {
10971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10972 }
10973 arg2 = static_cast< int >(val2);
10974 if (swig_obj[2]) {
10975 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10976 if (!SWIG_IsOK(ecode3)) {
10977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10978 }
10979 arg3 = static_cast< bool >(val3);
10980 }
10981 {
10982 if (!wxPyCheckForApp()) SWIG_fail;
10983 PyThreadState* __tstate = wxPyBeginAllowThreads();
10984 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10985 wxPyEndAllowThreads(__tstate);
10986 if (PyErr_Occurred()) SWIG_fail;
10987 }
10988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10989 return resultobj;
10990 fail:
10991 return NULL;
10992 }
10993
10994
10995 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10996 int argc;
10997 PyObject *argv[4];
10998
10999 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
11000 --argc;
11001 if (argc == 1) {
11002 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
11003 }
11004 if ((argc >= 2) && (argc <= 3)) {
11005 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
11006 }
11007
11008 fail:
11009 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
11010 return NULL;
11011 }
11012
11013
11014 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 PyObject *resultobj = 0;
11016 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11017 void *argp1 = 0 ;
11018 int res1 = 0 ;
11019 PyObject *swig_obj[1] ;
11020
11021 if (!args) SWIG_fail;
11022 swig_obj[0] = args;
11023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
11024 if (!SWIG_IsOK(res1)) {
11025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11026 }
11027 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11028 {
11029 PyThreadState* __tstate = wxPyBeginAllowThreads();
11030 delete arg1;
11031
11032 wxPyEndAllowThreads(__tstate);
11033 if (PyErr_Occurred()) SWIG_fail;
11034 }
11035 resultobj = SWIG_Py_Void();
11036 return resultobj;
11037 fail:
11038 return NULL;
11039 }
11040
11041
11042 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11043 PyObject *resultobj = 0;
11044 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
11045 int arg2 ;
11046 bool arg3 = (bool) false ;
11047 void *argp1 = 0 ;
11048 int res1 = 0 ;
11049 int val2 ;
11050 int ecode2 = 0 ;
11051 bool val3 ;
11052 int ecode3 = 0 ;
11053 PyObject * obj0 = 0 ;
11054 PyObject * obj1 = 0 ;
11055 PyObject * obj2 = 0 ;
11056 char * kwnames[] = {
11057 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
11058 };
11059
11060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
11062 if (!SWIG_IsOK(res1)) {
11063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
11064 }
11065 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
11066 ecode2 = SWIG_AsVal_int(obj1, &val2);
11067 if (!SWIG_IsOK(ecode2)) {
11068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
11069 }
11070 arg2 = static_cast< int >(val2);
11071 if (obj2) {
11072 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11073 if (!SWIG_IsOK(ecode3)) {
11074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
11075 }
11076 arg3 = static_cast< bool >(val3);
11077 }
11078 {
11079 PyThreadState* __tstate = wxPyBeginAllowThreads();
11080 (arg1)->Start(arg2,arg3);
11081 wxPyEndAllowThreads(__tstate);
11082 if (PyErr_Occurred()) SWIG_fail;
11083 }
11084 resultobj = SWIG_Py_Void();
11085 return resultobj;
11086 fail:
11087 return NULL;
11088 }
11089
11090
11091 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11092 PyObject *obj;
11093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11094 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
11095 return SWIG_Py_Void();
11096 }
11097
11098 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11099 return SWIG_Python_InitShadowInstance(args);
11100 }
11101
11102 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11103 PyObject *resultobj = 0;
11104 wxLog *result = 0 ;
11105
11106 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
11107 {
11108 PyThreadState* __tstate = wxPyBeginAllowThreads();
11109 result = (wxLog *)new wxLog();
11110 wxPyEndAllowThreads(__tstate);
11111 if (PyErr_Occurred()) SWIG_fail;
11112 }
11113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
11114 return resultobj;
11115 fail:
11116 return NULL;
11117 }
11118
11119
11120 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11121 PyObject *resultobj = 0;
11122 wxLog *arg1 = (wxLog *) 0 ;
11123 void *argp1 = 0 ;
11124 int res1 = 0 ;
11125 PyObject *swig_obj[1] ;
11126
11127 if (!args) SWIG_fail;
11128 swig_obj[0] = args;
11129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11130 if (!SWIG_IsOK(res1)) {
11131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
11132 }
11133 arg1 = reinterpret_cast< wxLog * >(argp1);
11134 {
11135 PyThreadState* __tstate = wxPyBeginAllowThreads();
11136 delete arg1;
11137
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 resultobj = SWIG_Py_Void();
11142 return resultobj;
11143 fail:
11144 return NULL;
11145 }
11146
11147
11148 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11149 PyObject *resultobj = 0;
11150 bool result;
11151
11152 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11153 {
11154 PyThreadState* __tstate = wxPyBeginAllowThreads();
11155 result = (bool)wxLog::IsEnabled();
11156 wxPyEndAllowThreads(__tstate);
11157 if (PyErr_Occurred()) SWIG_fail;
11158 }
11159 {
11160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11161 }
11162 return resultobj;
11163 fail:
11164 return NULL;
11165 }
11166
11167
11168 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11169 PyObject *resultobj = 0;
11170 bool arg1 = (bool) true ;
11171 bool result;
11172 bool val1 ;
11173 int ecode1 = 0 ;
11174 PyObject * obj0 = 0 ;
11175 char * kwnames[] = {
11176 (char *) "doIt", NULL
11177 };
11178
11179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11180 if (obj0) {
11181 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11182 if (!SWIG_IsOK(ecode1)) {
11183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11184 }
11185 arg1 = static_cast< bool >(val1);
11186 }
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (bool)wxLog::EnableLogging(arg1);
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 {
11194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11195 }
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11203 PyObject *resultobj = 0;
11204 wxLogLevel arg1 ;
11205 wxChar *arg2 = (wxChar *) 0 ;
11206 time_t arg3 ;
11207 unsigned long val1 ;
11208 int ecode1 = 0 ;
11209 void *argp2 = 0 ;
11210 int res2 = 0 ;
11211 unsigned int val3 ;
11212 int ecode3 = 0 ;
11213 PyObject * obj0 = 0 ;
11214 PyObject * obj1 = 0 ;
11215 PyObject * obj2 = 0 ;
11216 char * kwnames[] = {
11217 (char *) "level",(char *) "szString",(char *) "t", NULL
11218 };
11219
11220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11221 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11222 if (!SWIG_IsOK(ecode1)) {
11223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11224 }
11225 arg1 = static_cast< wxLogLevel >(val1);
11226 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11227 if (!SWIG_IsOK(res2)) {
11228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11229 }
11230 arg2 = reinterpret_cast< wxChar * >(argp2);
11231 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11232 if (!SWIG_IsOK(ecode3)) {
11233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11234 }
11235 arg3 = static_cast< time_t >(val3);
11236 {
11237 PyThreadState* __tstate = wxPyBeginAllowThreads();
11238 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11239 wxPyEndAllowThreads(__tstate);
11240 if (PyErr_Occurred()) SWIG_fail;
11241 }
11242 resultobj = SWIG_Py_Void();
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250 PyObject *resultobj = 0;
11251 wxLog *arg1 = (wxLog *) 0 ;
11252 void *argp1 = 0 ;
11253 int res1 = 0 ;
11254 PyObject *swig_obj[1] ;
11255
11256 if (!args) SWIG_fail;
11257 swig_obj[0] = args;
11258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11259 if (!SWIG_IsOK(res1)) {
11260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11261 }
11262 arg1 = reinterpret_cast< wxLog * >(argp1);
11263 {
11264 PyThreadState* __tstate = wxPyBeginAllowThreads();
11265 (arg1)->Flush();
11266 wxPyEndAllowThreads(__tstate);
11267 if (PyErr_Occurred()) SWIG_fail;
11268 }
11269 resultobj = SWIG_Py_Void();
11270 return resultobj;
11271 fail:
11272 return NULL;
11273 }
11274
11275
11276 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11277 PyObject *resultobj = 0;
11278
11279 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11280 {
11281 PyThreadState* __tstate = wxPyBeginAllowThreads();
11282 wxLog::FlushActive();
11283 wxPyEndAllowThreads(__tstate);
11284 if (PyErr_Occurred()) SWIG_fail;
11285 }
11286 resultobj = SWIG_Py_Void();
11287 return resultobj;
11288 fail:
11289 return NULL;
11290 }
11291
11292
11293 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11294 PyObject *resultobj = 0;
11295 wxLog *result = 0 ;
11296
11297 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = (wxLog *)wxLog::GetActiveTarget();
11301 wxPyEndAllowThreads(__tstate);
11302 if (PyErr_Occurred()) SWIG_fail;
11303 }
11304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11305 return resultobj;
11306 fail:
11307 return NULL;
11308 }
11309
11310
11311 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11312 PyObject *resultobj = 0;
11313 wxLog *arg1 = (wxLog *) 0 ;
11314 wxLog *result = 0 ;
11315 int res1 = 0 ;
11316 PyObject * obj0 = 0 ;
11317 char * kwnames[] = {
11318 (char *) "pLogger", NULL
11319 };
11320
11321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11322 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11323 if (!SWIG_IsOK(res1)) {
11324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11325 }
11326 {
11327 PyThreadState* __tstate = wxPyBeginAllowThreads();
11328 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11329 wxPyEndAllowThreads(__tstate);
11330 if (PyErr_Occurred()) SWIG_fail;
11331 }
11332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11333 return resultobj;
11334 fail:
11335 return NULL;
11336 }
11337
11338
11339 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11340 PyObject *resultobj = 0;
11341
11342 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 wxLog::Suspend();
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 resultobj = SWIG_Py_Void();
11350 return resultobj;
11351 fail:
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11357 PyObject *resultobj = 0;
11358
11359 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11360 {
11361 PyThreadState* __tstate = wxPyBeginAllowThreads();
11362 wxLog::Resume();
11363 wxPyEndAllowThreads(__tstate);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 resultobj = SWIG_Py_Void();
11367 return resultobj;
11368 fail:
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 bool arg1 = (bool) true ;
11376 bool val1 ;
11377 int ecode1 = 0 ;
11378 PyObject * obj0 = 0 ;
11379 char * kwnames[] = {
11380 (char *) "bVerbose", NULL
11381 };
11382
11383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11384 if (obj0) {
11385 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11386 if (!SWIG_IsOK(ecode1)) {
11387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11388 }
11389 arg1 = static_cast< bool >(val1);
11390 }
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 wxLog::SetVerbose(arg1);
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 resultobj = SWIG_Py_Void();
11398 return resultobj;
11399 fail:
11400 return NULL;
11401 }
11402
11403
11404 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj = 0;
11406 wxLogLevel arg1 ;
11407 unsigned long val1 ;
11408 int ecode1 = 0 ;
11409 PyObject * obj0 = 0 ;
11410 char * kwnames[] = {
11411 (char *) "logLevel", NULL
11412 };
11413
11414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11415 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11416 if (!SWIG_IsOK(ecode1)) {
11417 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11418 }
11419 arg1 = static_cast< wxLogLevel >(val1);
11420 {
11421 PyThreadState* __tstate = wxPyBeginAllowThreads();
11422 wxLog::SetLogLevel(arg1);
11423 wxPyEndAllowThreads(__tstate);
11424 if (PyErr_Occurred()) SWIG_fail;
11425 }
11426 resultobj = SWIG_Py_Void();
11427 return resultobj;
11428 fail:
11429 return NULL;
11430 }
11431
11432
11433 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11434 PyObject *resultobj = 0;
11435
11436 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11437 {
11438 PyThreadState* __tstate = wxPyBeginAllowThreads();
11439 wxLog::DontCreateOnDemand();
11440 wxPyEndAllowThreads(__tstate);
11441 if (PyErr_Occurred()) SWIG_fail;
11442 }
11443 resultobj = SWIG_Py_Void();
11444 return resultobj;
11445 fail:
11446 return NULL;
11447 }
11448
11449
11450 SWIGINTERN PyObject *_wrap_Log_SetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj = 0;
11452 bool arg1 = (bool) true ;
11453 bool val1 ;
11454 int ecode1 = 0 ;
11455 PyObject * obj0 = 0 ;
11456 char * kwnames[] = {
11457 (char *) "bRepetCounting", NULL
11458 };
11459
11460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetRepetitionCounting",kwnames,&obj0)) SWIG_fail;
11461 if (obj0) {
11462 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11463 if (!SWIG_IsOK(ecode1)) {
11464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetRepetitionCounting" "', expected argument " "1"" of type '" "bool""'");
11465 }
11466 arg1 = static_cast< bool >(val1);
11467 }
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 wxLog::SetRepetitionCounting(arg1);
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 resultobj = SWIG_Py_Void();
11475 return resultobj;
11476 fail:
11477 return NULL;
11478 }
11479
11480
11481 SWIGINTERN PyObject *_wrap_Log_GetRepetitionCounting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11482 PyObject *resultobj = 0;
11483 bool result;
11484
11485 if (!SWIG_Python_UnpackTuple(args,"Log_GetRepetitionCounting",0,0,0)) SWIG_fail;
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 result = (bool)wxLog::GetRepetitionCounting();
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 {
11493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11494 }
11495 return resultobj;
11496 fail:
11497 return NULL;
11498 }
11499
11500
11501 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj = 0;
11503 wxTraceMask arg1 ;
11504 unsigned long val1 ;
11505 int ecode1 = 0 ;
11506 PyObject * obj0 = 0 ;
11507 char * kwnames[] = {
11508 (char *) "ulMask", NULL
11509 };
11510
11511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11512 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11513 if (!SWIG_IsOK(ecode1)) {
11514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11515 }
11516 arg1 = static_cast< wxTraceMask >(val1);
11517 {
11518 PyThreadState* __tstate = wxPyBeginAllowThreads();
11519 wxLog::SetTraceMask(arg1);
11520 wxPyEndAllowThreads(__tstate);
11521 if (PyErr_Occurred()) SWIG_fail;
11522 }
11523 resultobj = SWIG_Py_Void();
11524 return resultobj;
11525 fail:
11526 return NULL;
11527 }
11528
11529
11530 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11531 PyObject *resultobj = 0;
11532 wxString *arg1 = 0 ;
11533 bool temp1 = false ;
11534 PyObject * obj0 = 0 ;
11535 char * kwnames[] = {
11536 (char *) "str", NULL
11537 };
11538
11539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11540 {
11541 arg1 = wxString_in_helper(obj0);
11542 if (arg1 == NULL) SWIG_fail;
11543 temp1 = true;
11544 }
11545 {
11546 PyThreadState* __tstate = wxPyBeginAllowThreads();
11547 wxLog::AddTraceMask((wxString const &)*arg1);
11548 wxPyEndAllowThreads(__tstate);
11549 if (PyErr_Occurred()) SWIG_fail;
11550 }
11551 resultobj = SWIG_Py_Void();
11552 {
11553 if (temp1)
11554 delete arg1;
11555 }
11556 return resultobj;
11557 fail:
11558 {
11559 if (temp1)
11560 delete arg1;
11561 }
11562 return NULL;
11563 }
11564
11565
11566 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11567 PyObject *resultobj = 0;
11568 wxString *arg1 = 0 ;
11569 bool temp1 = false ;
11570 PyObject * obj0 = 0 ;
11571 char * kwnames[] = {
11572 (char *) "str", NULL
11573 };
11574
11575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11576 {
11577 arg1 = wxString_in_helper(obj0);
11578 if (arg1 == NULL) SWIG_fail;
11579 temp1 = true;
11580 }
11581 {
11582 PyThreadState* __tstate = wxPyBeginAllowThreads();
11583 wxLog::RemoveTraceMask((wxString const &)*arg1);
11584 wxPyEndAllowThreads(__tstate);
11585 if (PyErr_Occurred()) SWIG_fail;
11586 }
11587 resultobj = SWIG_Py_Void();
11588 {
11589 if (temp1)
11590 delete arg1;
11591 }
11592 return resultobj;
11593 fail:
11594 {
11595 if (temp1)
11596 delete arg1;
11597 }
11598 return NULL;
11599 }
11600
11601
11602 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11603 PyObject *resultobj = 0;
11604
11605 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 wxLog::ClearTraceMasks();
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 resultobj = SWIG_Py_Void();
11613 return resultobj;
11614 fail:
11615 return NULL;
11616 }
11617
11618
11619 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11620 PyObject *resultobj = 0;
11621 wxArrayString *result = 0 ;
11622
11623 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11624 {
11625 PyThreadState* __tstate = wxPyBeginAllowThreads();
11626 {
11627 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11628 result = (wxArrayString *) &_result_ref;
11629 }
11630 wxPyEndAllowThreads(__tstate);
11631 if (PyErr_Occurred()) SWIG_fail;
11632 }
11633 {
11634 resultobj = wxArrayString2PyList_helper(*result);
11635 }
11636 return resultobj;
11637 fail:
11638 return NULL;
11639 }
11640
11641
11642 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11643 PyObject *resultobj = 0;
11644 wxChar *arg1 = (wxChar *) 0 ;
11645 void *argp1 = 0 ;
11646 int res1 = 0 ;
11647 PyObject * obj0 = 0 ;
11648 char * kwnames[] = {
11649 (char *) "ts", NULL
11650 };
11651
11652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11656 }
11657 arg1 = reinterpret_cast< wxChar * >(argp1);
11658 {
11659 PyThreadState* __tstate = wxPyBeginAllowThreads();
11660 wxLog::SetTimestamp((wxChar const *)arg1);
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 resultobj = SWIG_Py_Void();
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11672 PyObject *resultobj = 0;
11673 bool result;
11674
11675 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11676 {
11677 PyThreadState* __tstate = wxPyBeginAllowThreads();
11678 result = (bool)wxLog::GetVerbose();
11679 wxPyEndAllowThreads(__tstate);
11680 if (PyErr_Occurred()) SWIG_fail;
11681 }
11682 {
11683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11684 }
11685 return resultobj;
11686 fail:
11687 return NULL;
11688 }
11689
11690
11691 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11692 PyObject *resultobj = 0;
11693 wxTraceMask result;
11694
11695 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11696 {
11697 PyThreadState* __tstate = wxPyBeginAllowThreads();
11698 result = (wxTraceMask)wxLog::GetTraceMask();
11699 wxPyEndAllowThreads(__tstate);
11700 if (PyErr_Occurred()) SWIG_fail;
11701 }
11702 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11703 return resultobj;
11704 fail:
11705 return NULL;
11706 }
11707
11708
11709 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11710 PyObject *resultobj = 0;
11711 wxChar *arg1 = (wxChar *) 0 ;
11712 bool result;
11713 void *argp1 = 0 ;
11714 int res1 = 0 ;
11715 PyObject * obj0 = 0 ;
11716 char * kwnames[] = {
11717 (char *) "mask", NULL
11718 };
11719
11720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11722 if (!SWIG_IsOK(res1)) {
11723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11724 }
11725 arg1 = reinterpret_cast< wxChar * >(argp1);
11726 {
11727 PyThreadState* __tstate = wxPyBeginAllowThreads();
11728 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11729 wxPyEndAllowThreads(__tstate);
11730 if (PyErr_Occurred()) SWIG_fail;
11731 }
11732 {
11733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11734 }
11735 return resultobj;
11736 fail:
11737 return NULL;
11738 }
11739
11740
11741 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11742 PyObject *resultobj = 0;
11743 wxLogLevel result;
11744
11745 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 result = (wxLogLevel)wxLog::GetLogLevel();
11749 wxPyEndAllowThreads(__tstate);
11750 if (PyErr_Occurred()) SWIG_fail;
11751 }
11752 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11760 PyObject *resultobj = 0;
11761 wxChar *result = 0 ;
11762
11763 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11764 {
11765 PyThreadState* __tstate = wxPyBeginAllowThreads();
11766 result = (wxChar *)wxLog::GetTimestamp();
11767 wxPyEndAllowThreads(__tstate);
11768 if (PyErr_Occurred()) SWIG_fail;
11769 }
11770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11771 return resultobj;
11772 fail:
11773 return NULL;
11774 }
11775
11776
11777 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11778 PyObject *resultobj = 0;
11779 wxString result;
11780
11781 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11782 {
11783 PyThreadState* __tstate = wxPyBeginAllowThreads();
11784 result = wxLog_TimeStamp();
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 {
11789 #if wxUSE_UNICODE
11790 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11791 #else
11792 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11793 #endif
11794 }
11795 return resultobj;
11796 fail:
11797 return NULL;
11798 }
11799
11800
11801 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11802 PyObject *resultobj = 0;
11803 wxLog *arg1 = (wxLog *) 0 ;
11804 void *argp1 = 0 ;
11805 int res1 = 0 ;
11806 PyObject *swig_obj[1] ;
11807
11808 if (!args) SWIG_fail;
11809 swig_obj[0] = args;
11810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11811 if (!SWIG_IsOK(res1)) {
11812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11813 }
11814 arg1 = reinterpret_cast< wxLog * >(argp1);
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 wxLog_Destroy(arg1);
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 resultobj = SWIG_Py_Void();
11822 return resultobj;
11823 fail:
11824 return NULL;
11825 }
11826
11827
11828 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11829 PyObject *obj;
11830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11831 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11832 return SWIG_Py_Void();
11833 }
11834
11835 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11836 return SWIG_Python_InitShadowInstance(args);
11837 }
11838
11839 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11840 PyObject *resultobj = 0;
11841 wxLogStderr *result = 0 ;
11842
11843 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11844 {
11845 PyThreadState* __tstate = wxPyBeginAllowThreads();
11846 result = (wxLogStderr *)new wxLogStderr();
11847 wxPyEndAllowThreads(__tstate);
11848 if (PyErr_Occurred()) SWIG_fail;
11849 }
11850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11851 return resultobj;
11852 fail:
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11858 PyObject *obj;
11859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11860 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11861 return SWIG_Py_Void();
11862 }
11863
11864 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 return SWIG_Python_InitShadowInstance(args);
11866 }
11867
11868 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj = 0;
11870 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11871 wxLogTextCtrl *result = 0 ;
11872 void *argp1 = 0 ;
11873 int res1 = 0 ;
11874 PyObject * obj0 = 0 ;
11875 char * kwnames[] = {
11876 (char *) "pTextCtrl", NULL
11877 };
11878
11879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11881 if (!SWIG_IsOK(res1)) {
11882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11883 }
11884 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11885 {
11886 PyThreadState* __tstate = wxPyBeginAllowThreads();
11887 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11888 wxPyEndAllowThreads(__tstate);
11889 if (PyErr_Occurred()) SWIG_fail;
11890 }
11891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11892 return resultobj;
11893 fail:
11894 return NULL;
11895 }
11896
11897
11898 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11899 PyObject *obj;
11900 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11901 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11902 return SWIG_Py_Void();
11903 }
11904
11905 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11906 return SWIG_Python_InitShadowInstance(args);
11907 }
11908
11909 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11910 PyObject *resultobj = 0;
11911 wxLogGui *result = 0 ;
11912
11913 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 result = (wxLogGui *)new wxLogGui();
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11921 return resultobj;
11922 fail:
11923 return NULL;
11924 }
11925
11926
11927 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11928 PyObject *obj;
11929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11930 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11931 return SWIG_Py_Void();
11932 }
11933
11934 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11935 return SWIG_Python_InitShadowInstance(args);
11936 }
11937
11938 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11939 PyObject *resultobj = 0;
11940 wxFrame *arg1 = (wxFrame *) 0 ;
11941 wxString *arg2 = 0 ;
11942 bool arg3 = (bool) true ;
11943 bool arg4 = (bool) true ;
11944 wxLogWindow *result = 0 ;
11945 void *argp1 = 0 ;
11946 int res1 = 0 ;
11947 bool temp2 = false ;
11948 bool val3 ;
11949 int ecode3 = 0 ;
11950 bool val4 ;
11951 int ecode4 = 0 ;
11952 PyObject * obj0 = 0 ;
11953 PyObject * obj1 = 0 ;
11954 PyObject * obj2 = 0 ;
11955 PyObject * obj3 = 0 ;
11956 char * kwnames[] = {
11957 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11958 };
11959
11960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11962 if (!SWIG_IsOK(res1)) {
11963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11964 }
11965 arg1 = reinterpret_cast< wxFrame * >(argp1);
11966 {
11967 arg2 = wxString_in_helper(obj1);
11968 if (arg2 == NULL) SWIG_fail;
11969 temp2 = true;
11970 }
11971 if (obj2) {
11972 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11973 if (!SWIG_IsOK(ecode3)) {
11974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11975 }
11976 arg3 = static_cast< bool >(val3);
11977 }
11978 if (obj3) {
11979 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11980 if (!SWIG_IsOK(ecode4)) {
11981 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11982 }
11983 arg4 = static_cast< bool >(val4);
11984 }
11985 {
11986 PyThreadState* __tstate = wxPyBeginAllowThreads();
11987 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11992 {
11993 if (temp2)
11994 delete arg2;
11995 }
11996 return resultobj;
11997 fail:
11998 {
11999 if (temp2)
12000 delete arg2;
12001 }
12002 return NULL;
12003 }
12004
12005
12006 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12007 PyObject *resultobj = 0;
12008 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12009 bool arg2 = (bool) true ;
12010 void *argp1 = 0 ;
12011 int res1 = 0 ;
12012 bool val2 ;
12013 int ecode2 = 0 ;
12014 PyObject * obj0 = 0 ;
12015 PyObject * obj1 = 0 ;
12016 char * kwnames[] = {
12017 (char *) "self",(char *) "bShow", NULL
12018 };
12019
12020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
12021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12022 if (!SWIG_IsOK(res1)) {
12023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12024 }
12025 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12026 if (obj1) {
12027 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12028 if (!SWIG_IsOK(ecode2)) {
12029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
12030 }
12031 arg2 = static_cast< bool >(val2);
12032 }
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 (arg1)->Show(arg2);
12036 wxPyEndAllowThreads(__tstate);
12037 if (PyErr_Occurred()) SWIG_fail;
12038 }
12039 resultobj = SWIG_Py_Void();
12040 return resultobj;
12041 fail:
12042 return NULL;
12043 }
12044
12045
12046 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12047 PyObject *resultobj = 0;
12048 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12049 wxFrame *result = 0 ;
12050 void *argp1 = 0 ;
12051 int res1 = 0 ;
12052 PyObject *swig_obj[1] ;
12053
12054 if (!args) SWIG_fail;
12055 swig_obj[0] = args;
12056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12057 if (!SWIG_IsOK(res1)) {
12058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12059 }
12060 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 {
12068 resultobj = wxPyMake_wxObject(result, (bool)0);
12069 }
12070 return resultobj;
12071 fail:
12072 return NULL;
12073 }
12074
12075
12076 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12077 PyObject *resultobj = 0;
12078 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12079 wxLog *result = 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_wxLogWindow, 0 | 0 );
12087 if (!SWIG_IsOK(res1)) {
12088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12089 }
12090 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12091 {
12092 PyThreadState* __tstate = wxPyBeginAllowThreads();
12093 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
12094 wxPyEndAllowThreads(__tstate);
12095 if (PyErr_Occurred()) SWIG_fail;
12096 }
12097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12098 return resultobj;
12099 fail:
12100 return NULL;
12101 }
12102
12103
12104 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12105 PyObject *resultobj = 0;
12106 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12107 bool result;
12108 void *argp1 = 0 ;
12109 int res1 = 0 ;
12110 PyObject *swig_obj[1] ;
12111
12112 if (!args) SWIG_fail;
12113 swig_obj[0] = args;
12114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12115 if (!SWIG_IsOK(res1)) {
12116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
12117 }
12118 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
12122 wxPyEndAllowThreads(__tstate);
12123 if (PyErr_Occurred()) SWIG_fail;
12124 }
12125 {
12126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12127 }
12128 return resultobj;
12129 fail:
12130 return NULL;
12131 }
12132
12133
12134 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj = 0;
12136 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
12137 bool arg2 ;
12138 void *argp1 = 0 ;
12139 int res1 = 0 ;
12140 bool val2 ;
12141 int ecode2 = 0 ;
12142 PyObject * obj0 = 0 ;
12143 PyObject * obj1 = 0 ;
12144 char * kwnames[] = {
12145 (char *) "self",(char *) "bDoPass", NULL
12146 };
12147
12148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
12150 if (!SWIG_IsOK(res1)) {
12151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
12152 }
12153 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
12154 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12155 if (!SWIG_IsOK(ecode2)) {
12156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12157 }
12158 arg2 = static_cast< bool >(val2);
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 (arg1)->PassMessages(arg2);
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_Py_Void();
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12173 PyObject *obj;
12174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12175 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
12176 return SWIG_Py_Void();
12177 }
12178
12179 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12180 return SWIG_Python_InitShadowInstance(args);
12181 }
12182
12183 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj = 0;
12185 wxLog *arg1 = (wxLog *) 0 ;
12186 wxLogChain *result = 0 ;
12187 void *argp1 = 0 ;
12188 int res1 = 0 ;
12189 PyObject * obj0 = 0 ;
12190 char * kwnames[] = {
12191 (char *) "logger", NULL
12192 };
12193
12194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
12195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
12196 if (!SWIG_IsOK(res1)) {
12197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
12198 }
12199 arg1 = reinterpret_cast< wxLog * >(argp1);
12200 {
12201 PyThreadState* __tstate = wxPyBeginAllowThreads();
12202 result = (wxLogChain *)new wxLogChain(arg1);
12203 wxPyEndAllowThreads(__tstate);
12204 if (PyErr_Occurred()) SWIG_fail;
12205 }
12206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12207 return resultobj;
12208 fail:
12209 return NULL;
12210 }
12211
12212
12213 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12214 PyObject *resultobj = 0;
12215 wxLogChain *arg1 = (wxLogChain *) 0 ;
12216 wxLog *arg2 = (wxLog *) 0 ;
12217 void *argp1 = 0 ;
12218 int res1 = 0 ;
12219 void *argp2 = 0 ;
12220 int res2 = 0 ;
12221 PyObject * obj0 = 0 ;
12222 PyObject * obj1 = 0 ;
12223 char * kwnames[] = {
12224 (char *) "self",(char *) "logger", NULL
12225 };
12226
12227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12229 if (!SWIG_IsOK(res1)) {
12230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12231 }
12232 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12234 if (!SWIG_IsOK(res2)) {
12235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12236 }
12237 arg2 = reinterpret_cast< wxLog * >(argp2);
12238 {
12239 PyThreadState* __tstate = wxPyBeginAllowThreads();
12240 (arg1)->SetLog(arg2);
12241 wxPyEndAllowThreads(__tstate);
12242 if (PyErr_Occurred()) SWIG_fail;
12243 }
12244 resultobj = SWIG_Py_Void();
12245 return resultobj;
12246 fail:
12247 return NULL;
12248 }
12249
12250
12251 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12252 PyObject *resultobj = 0;
12253 wxLogChain *arg1 = (wxLogChain *) 0 ;
12254 bool arg2 ;
12255 void *argp1 = 0 ;
12256 int res1 = 0 ;
12257 bool val2 ;
12258 int ecode2 = 0 ;
12259 PyObject * obj0 = 0 ;
12260 PyObject * obj1 = 0 ;
12261 char * kwnames[] = {
12262 (char *) "self",(char *) "bDoPass", NULL
12263 };
12264
12265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12267 if (!SWIG_IsOK(res1)) {
12268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12269 }
12270 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12271 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12272 if (!SWIG_IsOK(ecode2)) {
12273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12274 }
12275 arg2 = static_cast< bool >(val2);
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 (arg1)->PassMessages(arg2);
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 resultobj = SWIG_Py_Void();
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12290 PyObject *resultobj = 0;
12291 wxLogChain *arg1 = (wxLogChain *) 0 ;
12292 bool result;
12293 void *argp1 = 0 ;
12294 int res1 = 0 ;
12295 PyObject *swig_obj[1] ;
12296
12297 if (!args) SWIG_fail;
12298 swig_obj[0] = args;
12299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12300 if (!SWIG_IsOK(res1)) {
12301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12302 }
12303 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 result = (bool)(arg1)->IsPassingMessages();
12307 wxPyEndAllowThreads(__tstate);
12308 if (PyErr_Occurred()) SWIG_fail;
12309 }
12310 {
12311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12312 }
12313 return resultobj;
12314 fail:
12315 return NULL;
12316 }
12317
12318
12319 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320 PyObject *resultobj = 0;
12321 wxLogChain *arg1 = (wxLogChain *) 0 ;
12322 wxLog *result = 0 ;
12323 void *argp1 = 0 ;
12324 int res1 = 0 ;
12325 PyObject *swig_obj[1] ;
12326
12327 if (!args) SWIG_fail;
12328 swig_obj[0] = args;
12329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12330 if (!SWIG_IsOK(res1)) {
12331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12332 }
12333 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 result = (wxLog *)(arg1)->GetOldLog();
12337 wxPyEndAllowThreads(__tstate);
12338 if (PyErr_Occurred()) SWIG_fail;
12339 }
12340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12341 return resultobj;
12342 fail:
12343 return NULL;
12344 }
12345
12346
12347 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12348 PyObject *obj;
12349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12350 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12351 return SWIG_Py_Void();
12352 }
12353
12354 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12355 return SWIG_Python_InitShadowInstance(args);
12356 }
12357
12358 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12359 PyObject *resultobj = 0;
12360 wxLogBuffer *result = 0 ;
12361
12362 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 result = (wxLogBuffer *)new wxLogBuffer();
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12377 PyObject *resultobj = 0;
12378 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12379 wxString *result = 0 ;
12380 void *argp1 = 0 ;
12381 int res1 = 0 ;
12382 PyObject *swig_obj[1] ;
12383
12384 if (!args) SWIG_fail;
12385 swig_obj[0] = args;
12386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12387 if (!SWIG_IsOK(res1)) {
12388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12389 }
12390 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12391 {
12392 PyThreadState* __tstate = wxPyBeginAllowThreads();
12393 {
12394 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12395 result = (wxString *) &_result_ref;
12396 }
12397 wxPyEndAllowThreads(__tstate);
12398 if (PyErr_Occurred()) SWIG_fail;
12399 }
12400 {
12401 #if wxUSE_UNICODE
12402 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12403 #else
12404 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12405 #endif
12406 }
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12414 PyObject *obj;
12415 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12416 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12417 return SWIG_Py_Void();
12418 }
12419
12420 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12421 return SWIG_Python_InitShadowInstance(args);
12422 }
12423
12424 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12425 PyObject *resultobj = 0;
12426 unsigned long result;
12427
12428 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12429 {
12430 PyThreadState* __tstate = wxPyBeginAllowThreads();
12431 result = (unsigned long)wxSysErrorCode();
12432 wxPyEndAllowThreads(__tstate);
12433 if (PyErr_Occurred()) SWIG_fail;
12434 }
12435 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12443 PyObject *resultobj = 0;
12444 unsigned long arg1 = (unsigned long) 0 ;
12445 wxString result;
12446 unsigned long val1 ;
12447 int ecode1 = 0 ;
12448 PyObject * obj0 = 0 ;
12449 char * kwnames[] = {
12450 (char *) "nErrCode", NULL
12451 };
12452
12453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12454 if (obj0) {
12455 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12456 if (!SWIG_IsOK(ecode1)) {
12457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12458 }
12459 arg1 = static_cast< unsigned long >(val1);
12460 }
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 result = wxSysErrorMsg(arg1);
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 {
12468 #if wxUSE_UNICODE
12469 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12470 #else
12471 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12472 #endif
12473 }
12474 return resultobj;
12475 fail:
12476 return NULL;
12477 }
12478
12479
12480 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12481 PyObject *resultobj = 0;
12482 wxString *arg1 = 0 ;
12483 bool temp1 = false ;
12484 PyObject * obj0 = 0 ;
12485 char * kwnames[] = {
12486 (char *) "msg", NULL
12487 };
12488
12489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12490 {
12491 arg1 = wxString_in_helper(obj0);
12492 if (arg1 == NULL) SWIG_fail;
12493 temp1 = true;
12494 }
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 wxPyLogFatalError((wxString const &)*arg1);
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 resultobj = SWIG_Py_Void();
12502 {
12503 if (temp1)
12504 delete arg1;
12505 }
12506 return resultobj;
12507 fail:
12508 {
12509 if (temp1)
12510 delete arg1;
12511 }
12512 return NULL;
12513 }
12514
12515
12516 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj = 0;
12518 wxString *arg1 = 0 ;
12519 bool temp1 = false ;
12520 PyObject * obj0 = 0 ;
12521 char * kwnames[] = {
12522 (char *) "msg", NULL
12523 };
12524
12525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12526 {
12527 arg1 = wxString_in_helper(obj0);
12528 if (arg1 == NULL) SWIG_fail;
12529 temp1 = true;
12530 }
12531 {
12532 PyThreadState* __tstate = wxPyBeginAllowThreads();
12533 wxPyLogError((wxString const &)*arg1);
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 resultobj = SWIG_Py_Void();
12538 {
12539 if (temp1)
12540 delete arg1;
12541 }
12542 return resultobj;
12543 fail:
12544 {
12545 if (temp1)
12546 delete arg1;
12547 }
12548 return NULL;
12549 }
12550
12551
12552 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12553 PyObject *resultobj = 0;
12554 wxString *arg1 = 0 ;
12555 bool temp1 = false ;
12556 PyObject * obj0 = 0 ;
12557 char * kwnames[] = {
12558 (char *) "msg", NULL
12559 };
12560
12561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12562 {
12563 arg1 = wxString_in_helper(obj0);
12564 if (arg1 == NULL) SWIG_fail;
12565 temp1 = true;
12566 }
12567 {
12568 PyThreadState* __tstate = wxPyBeginAllowThreads();
12569 wxPyLogWarning((wxString const &)*arg1);
12570 wxPyEndAllowThreads(__tstate);
12571 if (PyErr_Occurred()) SWIG_fail;
12572 }
12573 resultobj = SWIG_Py_Void();
12574 {
12575 if (temp1)
12576 delete arg1;
12577 }
12578 return resultobj;
12579 fail:
12580 {
12581 if (temp1)
12582 delete arg1;
12583 }
12584 return NULL;
12585 }
12586
12587
12588 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12589 PyObject *resultobj = 0;
12590 wxString *arg1 = 0 ;
12591 bool temp1 = false ;
12592 PyObject * obj0 = 0 ;
12593 char * kwnames[] = {
12594 (char *) "msg", NULL
12595 };
12596
12597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12598 {
12599 arg1 = wxString_in_helper(obj0);
12600 if (arg1 == NULL) SWIG_fail;
12601 temp1 = true;
12602 }
12603 {
12604 PyThreadState* __tstate = wxPyBeginAllowThreads();
12605 wxPyLogMessage((wxString const &)*arg1);
12606 wxPyEndAllowThreads(__tstate);
12607 if (PyErr_Occurred()) SWIG_fail;
12608 }
12609 resultobj = SWIG_Py_Void();
12610 {
12611 if (temp1)
12612 delete arg1;
12613 }
12614 return resultobj;
12615 fail:
12616 {
12617 if (temp1)
12618 delete arg1;
12619 }
12620 return NULL;
12621 }
12622
12623
12624 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12625 PyObject *resultobj = 0;
12626 wxString *arg1 = 0 ;
12627 bool temp1 = false ;
12628 PyObject * obj0 = 0 ;
12629 char * kwnames[] = {
12630 (char *) "msg", NULL
12631 };
12632
12633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12634 {
12635 arg1 = wxString_in_helper(obj0);
12636 if (arg1 == NULL) SWIG_fail;
12637 temp1 = true;
12638 }
12639 {
12640 PyThreadState* __tstate = wxPyBeginAllowThreads();
12641 wxPyLogInfo((wxString const &)*arg1);
12642 wxPyEndAllowThreads(__tstate);
12643 if (PyErr_Occurred()) SWIG_fail;
12644 }
12645 resultobj = SWIG_Py_Void();
12646 {
12647 if (temp1)
12648 delete arg1;
12649 }
12650 return resultobj;
12651 fail:
12652 {
12653 if (temp1)
12654 delete arg1;
12655 }
12656 return NULL;
12657 }
12658
12659
12660 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12661 PyObject *resultobj = 0;
12662 wxString *arg1 = 0 ;
12663 bool temp1 = false ;
12664 PyObject * obj0 = 0 ;
12665 char * kwnames[] = {
12666 (char *) "msg", NULL
12667 };
12668
12669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12670 {
12671 arg1 = wxString_in_helper(obj0);
12672 if (arg1 == NULL) SWIG_fail;
12673 temp1 = true;
12674 }
12675 {
12676 PyThreadState* __tstate = wxPyBeginAllowThreads();
12677 wxPyLogDebug((wxString const &)*arg1);
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 resultobj = SWIG_Py_Void();
12682 {
12683 if (temp1)
12684 delete arg1;
12685 }
12686 return resultobj;
12687 fail:
12688 {
12689 if (temp1)
12690 delete arg1;
12691 }
12692 return NULL;
12693 }
12694
12695
12696 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12697 PyObject *resultobj = 0;
12698 wxString *arg1 = 0 ;
12699 bool temp1 = false ;
12700 PyObject * obj0 = 0 ;
12701 char * kwnames[] = {
12702 (char *) "msg", NULL
12703 };
12704
12705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12706 {
12707 arg1 = wxString_in_helper(obj0);
12708 if (arg1 == NULL) SWIG_fail;
12709 temp1 = true;
12710 }
12711 {
12712 PyThreadState* __tstate = wxPyBeginAllowThreads();
12713 wxPyLogVerbose((wxString const &)*arg1);
12714 wxPyEndAllowThreads(__tstate);
12715 if (PyErr_Occurred()) SWIG_fail;
12716 }
12717 resultobj = SWIG_Py_Void();
12718 {
12719 if (temp1)
12720 delete arg1;
12721 }
12722 return resultobj;
12723 fail:
12724 {
12725 if (temp1)
12726 delete arg1;
12727 }
12728 return NULL;
12729 }
12730
12731
12732 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12733 PyObject *resultobj = 0;
12734 wxString *arg1 = 0 ;
12735 bool temp1 = false ;
12736 PyObject * obj0 = 0 ;
12737 char * kwnames[] = {
12738 (char *) "msg", NULL
12739 };
12740
12741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12742 {
12743 arg1 = wxString_in_helper(obj0);
12744 if (arg1 == NULL) SWIG_fail;
12745 temp1 = true;
12746 }
12747 {
12748 PyThreadState* __tstate = wxPyBeginAllowThreads();
12749 wxPyLogStatus((wxString const &)*arg1);
12750 wxPyEndAllowThreads(__tstate);
12751 if (PyErr_Occurred()) SWIG_fail;
12752 }
12753 resultobj = SWIG_Py_Void();
12754 {
12755 if (temp1)
12756 delete arg1;
12757 }
12758 return resultobj;
12759 fail:
12760 {
12761 if (temp1)
12762 delete arg1;
12763 }
12764 return NULL;
12765 }
12766
12767
12768 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12769 PyObject *resultobj = 0;
12770 wxFrame *arg1 = (wxFrame *) 0 ;
12771 wxString *arg2 = 0 ;
12772 void *argp1 = 0 ;
12773 int res1 = 0 ;
12774 bool temp2 = false ;
12775 PyObject * obj0 = 0 ;
12776 PyObject * obj1 = 0 ;
12777 char * kwnames[] = {
12778 (char *) "pFrame",(char *) "msg", NULL
12779 };
12780
12781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12783 if (!SWIG_IsOK(res1)) {
12784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12785 }
12786 arg1 = reinterpret_cast< wxFrame * >(argp1);
12787 {
12788 arg2 = wxString_in_helper(obj1);
12789 if (arg2 == NULL) SWIG_fail;
12790 temp2 = true;
12791 }
12792 {
12793 PyThreadState* __tstate = wxPyBeginAllowThreads();
12794 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12795 wxPyEndAllowThreads(__tstate);
12796 if (PyErr_Occurred()) SWIG_fail;
12797 }
12798 resultobj = SWIG_Py_Void();
12799 {
12800 if (temp2)
12801 delete arg2;
12802 }
12803 return resultobj;
12804 fail:
12805 {
12806 if (temp2)
12807 delete arg2;
12808 }
12809 return NULL;
12810 }
12811
12812
12813 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12814 PyObject *resultobj = 0;
12815 wxString *arg1 = 0 ;
12816 bool temp1 = false ;
12817 PyObject * obj0 = 0 ;
12818 char * kwnames[] = {
12819 (char *) "msg", NULL
12820 };
12821
12822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12823 {
12824 arg1 = wxString_in_helper(obj0);
12825 if (arg1 == NULL) SWIG_fail;
12826 temp1 = true;
12827 }
12828 {
12829 PyThreadState* __tstate = wxPyBeginAllowThreads();
12830 wxPyLogSysError((wxString const &)*arg1);
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 resultobj = SWIG_Py_Void();
12835 {
12836 if (temp1)
12837 delete arg1;
12838 }
12839 return resultobj;
12840 fail:
12841 {
12842 if (temp1)
12843 delete arg1;
12844 }
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12850 PyObject *resultobj = 0;
12851 unsigned long arg1 ;
12852 wxString *arg2 = 0 ;
12853 unsigned long val1 ;
12854 int ecode1 = 0 ;
12855 bool temp2 = false ;
12856 PyObject * obj0 = 0 ;
12857 PyObject * obj1 = 0 ;
12858 char * kwnames[] = {
12859 (char *) "level",(char *) "msg", NULL
12860 };
12861
12862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12863 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12864 if (!SWIG_IsOK(ecode1)) {
12865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12866 }
12867 arg1 = static_cast< unsigned long >(val1);
12868 {
12869 arg2 = wxString_in_helper(obj1);
12870 if (arg2 == NULL) SWIG_fail;
12871 temp2 = true;
12872 }
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 resultobj = SWIG_Py_Void();
12880 {
12881 if (temp2)
12882 delete arg2;
12883 }
12884 return resultobj;
12885 fail:
12886 {
12887 if (temp2)
12888 delete arg2;
12889 }
12890 return NULL;
12891 }
12892
12893
12894 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12895 PyObject *resultobj = 0;
12896 unsigned long arg1 ;
12897 wxString *arg2 = 0 ;
12898 unsigned long val1 ;
12899 int ecode1 = 0 ;
12900 bool temp2 = false ;
12901
12902 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12903 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12904 if (!SWIG_IsOK(ecode1)) {
12905 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12906 }
12907 arg1 = static_cast< unsigned long >(val1);
12908 {
12909 arg2 = wxString_in_helper(swig_obj[1]);
12910 if (arg2 == NULL) SWIG_fail;
12911 temp2 = true;
12912 }
12913 {
12914 PyThreadState* __tstate = wxPyBeginAllowThreads();
12915 wxPyLogTrace(arg1,(wxString const &)*arg2);
12916 wxPyEndAllowThreads(__tstate);
12917 if (PyErr_Occurred()) SWIG_fail;
12918 }
12919 resultobj = SWIG_Py_Void();
12920 {
12921 if (temp2)
12922 delete arg2;
12923 }
12924 return resultobj;
12925 fail:
12926 {
12927 if (temp2)
12928 delete arg2;
12929 }
12930 return NULL;
12931 }
12932
12933
12934 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12935 PyObject *resultobj = 0;
12936 wxString *arg1 = 0 ;
12937 wxString *arg2 = 0 ;
12938 bool temp1 = false ;
12939 bool temp2 = false ;
12940
12941 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12942 {
12943 arg1 = wxString_in_helper(swig_obj[0]);
12944 if (arg1 == NULL) SWIG_fail;
12945 temp1 = true;
12946 }
12947 {
12948 arg2 = wxString_in_helper(swig_obj[1]);
12949 if (arg2 == NULL) SWIG_fail;
12950 temp2 = true;
12951 }
12952 {
12953 PyThreadState* __tstate = wxPyBeginAllowThreads();
12954 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12955 wxPyEndAllowThreads(__tstate);
12956 if (PyErr_Occurred()) SWIG_fail;
12957 }
12958 resultobj = SWIG_Py_Void();
12959 {
12960 if (temp1)
12961 delete arg1;
12962 }
12963 {
12964 if (temp2)
12965 delete arg2;
12966 }
12967 return resultobj;
12968 fail:
12969 {
12970 if (temp1)
12971 delete arg1;
12972 }
12973 {
12974 if (temp2)
12975 delete arg2;
12976 }
12977 return NULL;
12978 }
12979
12980
12981 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12982 int argc;
12983 PyObject *argv[3];
12984
12985 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12986 --argc;
12987 if (argc == 2) {
12988 int _v = 0;
12989 {
12990 {
12991 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12992 }
12993 }
12994 if (!_v) goto check_1;
12995 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12996 }
12997 check_1:
12998
12999 if (argc == 2) {
13000 return _wrap_LogTrace__SWIG_0(self, argc, argv);
13001 }
13002
13003 fail:
13004 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
13005 return NULL;
13006 }
13007
13008
13009 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13010 PyObject *resultobj = 0;
13011 wxString *arg1 = 0 ;
13012 wxString *arg2 = 0 ;
13013 bool temp1 = false ;
13014 bool temp2 = false ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 char * kwnames[] = {
13018 (char *) "title",(char *) "text", NULL
13019 };
13020
13021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
13022 {
13023 arg1 = wxString_in_helper(obj0);
13024 if (arg1 == NULL) SWIG_fail;
13025 temp1 = true;
13026 }
13027 {
13028 arg2 = wxString_in_helper(obj1);
13029 if (arg2 == NULL) SWIG_fail;
13030 temp2 = true;
13031 }
13032 {
13033 PyThreadState* __tstate = wxPyBeginAllowThreads();
13034 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
13035 wxPyEndAllowThreads(__tstate);
13036 if (PyErr_Occurred()) SWIG_fail;
13037 }
13038 resultobj = SWIG_Py_Void();
13039 {
13040 if (temp1)
13041 delete arg1;
13042 }
13043 {
13044 if (temp2)
13045 delete arg2;
13046 }
13047 return resultobj;
13048 fail:
13049 {
13050 if (temp1)
13051 delete arg1;
13052 }
13053 {
13054 if (temp2)
13055 delete arg2;
13056 }
13057 return NULL;
13058 }
13059
13060
13061 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13062 PyObject *resultobj = 0;
13063 wxLogNull *result = 0 ;
13064
13065 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
13066 {
13067 PyThreadState* __tstate = wxPyBeginAllowThreads();
13068 result = (wxLogNull *)new wxLogNull();
13069 wxPyEndAllowThreads(__tstate);
13070 if (PyErr_Occurred()) SWIG_fail;
13071 }
13072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
13073 return resultobj;
13074 fail:
13075 return NULL;
13076 }
13077
13078
13079 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13080 PyObject *resultobj = 0;
13081 wxLogNull *arg1 = (wxLogNull *) 0 ;
13082 void *argp1 = 0 ;
13083 int res1 = 0 ;
13084 PyObject *swig_obj[1] ;
13085
13086 if (!args) SWIG_fail;
13087 swig_obj[0] = args;
13088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
13089 if (!SWIG_IsOK(res1)) {
13090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
13091 }
13092 arg1 = reinterpret_cast< wxLogNull * >(argp1);
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 delete arg1;
13096
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 resultobj = SWIG_Py_Void();
13101 return resultobj;
13102 fail:
13103 return NULL;
13104 }
13105
13106
13107 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13108 PyObject *obj;
13109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13110 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
13111 return SWIG_Py_Void();
13112 }
13113
13114 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13115 return SWIG_Python_InitShadowInstance(args);
13116 }
13117
13118 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13119 PyObject *resultobj = 0;
13120 wxPyLog *result = 0 ;
13121
13122 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
13123 {
13124 PyThreadState* __tstate = wxPyBeginAllowThreads();
13125 result = (wxPyLog *)new wxPyLog();
13126 wxPyEndAllowThreads(__tstate);
13127 if (PyErr_Occurred()) SWIG_fail;
13128 }
13129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
13130 return resultobj;
13131 fail:
13132 return NULL;
13133 }
13134
13135
13136 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13137 PyObject *resultobj = 0;
13138 wxPyLog *arg1 = (wxPyLog *) 0 ;
13139 PyObject *arg2 = (PyObject *) 0 ;
13140 PyObject *arg3 = (PyObject *) 0 ;
13141 void *argp1 = 0 ;
13142 int res1 = 0 ;
13143 PyObject * obj0 = 0 ;
13144 PyObject * obj1 = 0 ;
13145 PyObject * obj2 = 0 ;
13146 char * kwnames[] = {
13147 (char *) "self",(char *) "self",(char *) "_class", NULL
13148 };
13149
13150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
13152 if (!SWIG_IsOK(res1)) {
13153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
13154 }
13155 arg1 = reinterpret_cast< wxPyLog * >(argp1);
13156 arg2 = obj1;
13157 arg3 = obj2;
13158 {
13159 PyThreadState* __tstate = wxPyBeginAllowThreads();
13160 (arg1)->_setCallbackInfo(arg2,arg3);
13161 wxPyEndAllowThreads(__tstate);
13162 if (PyErr_Occurred()) SWIG_fail;
13163 }
13164 resultobj = SWIG_Py_Void();
13165 return resultobj;
13166 fail:
13167 return NULL;
13168 }
13169
13170
13171 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13172 PyObject *obj;
13173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13174 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
13175 return SWIG_Py_Void();
13176 }
13177
13178 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13179 return SWIG_Python_InitShadowInstance(args);
13180 }
13181
13182 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13183 PyObject *resultobj = 0;
13184 int arg1 ;
13185 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13186 int arg3 = (int) wxKILL_NOCHILDREN ;
13187 wxKillError result;
13188 int val1 ;
13189 int ecode1 = 0 ;
13190 int val2 ;
13191 int ecode2 = 0 ;
13192 int val3 ;
13193 int ecode3 = 0 ;
13194 PyObject * obj0 = 0 ;
13195 PyObject * obj1 = 0 ;
13196 PyObject * obj2 = 0 ;
13197 char * kwnames[] = {
13198 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13199 };
13200
13201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13202 ecode1 = SWIG_AsVal_int(obj0, &val1);
13203 if (!SWIG_IsOK(ecode1)) {
13204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13205 }
13206 arg1 = static_cast< int >(val1);
13207 if (obj1) {
13208 ecode2 = SWIG_AsVal_int(obj1, &val2);
13209 if (!SWIG_IsOK(ecode2)) {
13210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13211 }
13212 arg2 = static_cast< wxSignal >(val2);
13213 }
13214 if (obj2) {
13215 ecode3 = SWIG_AsVal_int(obj2, &val3);
13216 if (!SWIG_IsOK(ecode3)) {
13217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13218 }
13219 arg3 = static_cast< int >(val3);
13220 }
13221 {
13222 PyThreadState* __tstate = wxPyBeginAllowThreads();
13223 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13224 wxPyEndAllowThreads(__tstate);
13225 if (PyErr_Occurred()) SWIG_fail;
13226 }
13227 resultobj = SWIG_From_int(static_cast< int >(result));
13228 return resultobj;
13229 fail:
13230 return NULL;
13231 }
13232
13233
13234 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13235 PyObject *resultobj = 0;
13236 int arg1 ;
13237 bool result;
13238 int val1 ;
13239 int ecode1 = 0 ;
13240 PyObject * obj0 = 0 ;
13241 char * kwnames[] = {
13242 (char *) "pid", NULL
13243 };
13244
13245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13246 ecode1 = SWIG_AsVal_int(obj0, &val1);
13247 if (!SWIG_IsOK(ecode1)) {
13248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13249 }
13250 arg1 = static_cast< int >(val1);
13251 {
13252 PyThreadState* __tstate = wxPyBeginAllowThreads();
13253 result = (bool)wxPyProcess::Exists(arg1);
13254 wxPyEndAllowThreads(__tstate);
13255 if (PyErr_Occurred()) SWIG_fail;
13256 }
13257 {
13258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13259 }
13260 return resultobj;
13261 fail:
13262 return NULL;
13263 }
13264
13265
13266 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj = 0;
13268 wxString *arg1 = 0 ;
13269 int arg2 = (int) wxEXEC_ASYNC ;
13270 wxPyProcess *result = 0 ;
13271 bool temp1 = false ;
13272 int val2 ;
13273 int ecode2 = 0 ;
13274 PyObject * obj0 = 0 ;
13275 PyObject * obj1 = 0 ;
13276 char * kwnames[] = {
13277 (char *) "cmd",(char *) "flags", NULL
13278 };
13279
13280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13281 {
13282 arg1 = wxString_in_helper(obj0);
13283 if (arg1 == NULL) SWIG_fail;
13284 temp1 = true;
13285 }
13286 if (obj1) {
13287 ecode2 = SWIG_AsVal_int(obj1, &val2);
13288 if (!SWIG_IsOK(ecode2)) {
13289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13290 }
13291 arg2 = static_cast< int >(val2);
13292 }
13293 {
13294 PyThreadState* __tstate = wxPyBeginAllowThreads();
13295 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13296 wxPyEndAllowThreads(__tstate);
13297 if (PyErr_Occurred()) SWIG_fail;
13298 }
13299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13300 {
13301 if (temp1)
13302 delete arg1;
13303 }
13304 return resultobj;
13305 fail:
13306 {
13307 if (temp1)
13308 delete arg1;
13309 }
13310 return NULL;
13311 }
13312
13313
13314 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj = 0;
13316 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13317 int arg2 = (int) -1 ;
13318 wxPyProcess *result = 0 ;
13319 void *argp1 = 0 ;
13320 int res1 = 0 ;
13321 int val2 ;
13322 int ecode2 = 0 ;
13323 PyObject * obj0 = 0 ;
13324 PyObject * obj1 = 0 ;
13325 char * kwnames[] = {
13326 (char *) "parent",(char *) "id", NULL
13327 };
13328
13329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13330 if (obj0) {
13331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13332 if (!SWIG_IsOK(res1)) {
13333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13334 }
13335 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13336 }
13337 if (obj1) {
13338 ecode2 = SWIG_AsVal_int(obj1, &val2);
13339 if (!SWIG_IsOK(ecode2)) {
13340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13341 }
13342 arg2 = static_cast< int >(val2);
13343 }
13344 {
13345 PyThreadState* __tstate = wxPyBeginAllowThreads();
13346 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13351 return resultobj;
13352 fail:
13353 return NULL;
13354 }
13355
13356
13357 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13358 PyObject *resultobj = 0;
13359 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13360 PyObject *arg2 = (PyObject *) 0 ;
13361 PyObject *arg3 = (PyObject *) 0 ;
13362 void *argp1 = 0 ;
13363 int res1 = 0 ;
13364 PyObject * obj0 = 0 ;
13365 PyObject * obj1 = 0 ;
13366 PyObject * obj2 = 0 ;
13367 char * kwnames[] = {
13368 (char *) "self",(char *) "self",(char *) "_class", NULL
13369 };
13370
13371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13373 if (!SWIG_IsOK(res1)) {
13374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13375 }
13376 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13377 arg2 = obj1;
13378 arg3 = obj2;
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 (arg1)->_setCallbackInfo(arg2,arg3);
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 resultobj = SWIG_Py_Void();
13386 return resultobj;
13387 fail:
13388 return NULL;
13389 }
13390
13391
13392 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13393 PyObject *resultobj = 0;
13394 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13395 int arg2 ;
13396 int arg3 ;
13397 void *argp1 = 0 ;
13398 int res1 = 0 ;
13399 int val2 ;
13400 int ecode2 = 0 ;
13401 int val3 ;
13402 int ecode3 = 0 ;
13403 PyObject * obj0 = 0 ;
13404 PyObject * obj1 = 0 ;
13405 PyObject * obj2 = 0 ;
13406 char * kwnames[] = {
13407 (char *) "self",(char *) "pid",(char *) "status", NULL
13408 };
13409
13410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13412 if (!SWIG_IsOK(res1)) {
13413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13414 }
13415 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13416 ecode2 = SWIG_AsVal_int(obj1, &val2);
13417 if (!SWIG_IsOK(ecode2)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13419 }
13420 arg2 = static_cast< int >(val2);
13421 ecode3 = SWIG_AsVal_int(obj2, &val3);
13422 if (!SWIG_IsOK(ecode3)) {
13423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13424 }
13425 arg3 = static_cast< int >(val3);
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 (arg1)->OnTerminate(arg2,arg3);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 resultobj = SWIG_Py_Void();
13433 return resultobj;
13434 fail:
13435 return NULL;
13436 }
13437
13438
13439 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13440 PyObject *resultobj = 0;
13441 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13442 void *argp1 = 0 ;
13443 int res1 = 0 ;
13444 PyObject *swig_obj[1] ;
13445
13446 if (!args) SWIG_fail;
13447 swig_obj[0] = args;
13448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13449 if (!SWIG_IsOK(res1)) {
13450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13451 }
13452 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 (arg1)->Redirect();
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 resultobj = SWIG_Py_Void();
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13467 PyObject *resultobj = 0;
13468 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13469 bool result;
13470 void *argp1 = 0 ;
13471 int res1 = 0 ;
13472 PyObject *swig_obj[1] ;
13473
13474 if (!args) SWIG_fail;
13475 swig_obj[0] = args;
13476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13477 if (!SWIG_IsOK(res1)) {
13478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13479 }
13480 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 result = (bool)(arg1)->IsRedirected();
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 {
13488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13489 }
13490 return resultobj;
13491 fail:
13492 return NULL;
13493 }
13494
13495
13496 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13497 PyObject *resultobj = 0;
13498 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13499 void *argp1 = 0 ;
13500 int res1 = 0 ;
13501 PyObject *swig_obj[1] ;
13502
13503 if (!args) SWIG_fail;
13504 swig_obj[0] = args;
13505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13506 if (!SWIG_IsOK(res1)) {
13507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13508 }
13509 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 (arg1)->Detach();
13513 wxPyEndAllowThreads(__tstate);
13514 if (PyErr_Occurred()) SWIG_fail;
13515 }
13516 resultobj = SWIG_Py_Void();
13517 return resultobj;
13518 fail:
13519 return NULL;
13520 }
13521
13522
13523 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13524 PyObject *resultobj = 0;
13525 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13526 wxInputStream *result = 0 ;
13527 void *argp1 = 0 ;
13528 int res1 = 0 ;
13529 PyObject *swig_obj[1] ;
13530
13531 if (!args) SWIG_fail;
13532 swig_obj[0] = args;
13533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13534 if (!SWIG_IsOK(res1)) {
13535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13536 }
13537 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13538 {
13539 PyThreadState* __tstate = wxPyBeginAllowThreads();
13540 result = (wxInputStream *)(arg1)->GetInputStream();
13541 wxPyEndAllowThreads(__tstate);
13542 if (PyErr_Occurred()) SWIG_fail;
13543 }
13544 {
13545 wxPyInputStream * _ptr = NULL;
13546
13547 if (result) {
13548 _ptr = new wxPyInputStream(result);
13549 }
13550 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13551 }
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13559 PyObject *resultobj = 0;
13560 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13561 wxInputStream *result = 0 ;
13562 void *argp1 = 0 ;
13563 int res1 = 0 ;
13564 PyObject *swig_obj[1] ;
13565
13566 if (!args) SWIG_fail;
13567 swig_obj[0] = args;
13568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13569 if (!SWIG_IsOK(res1)) {
13570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13571 }
13572 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13573 {
13574 PyThreadState* __tstate = wxPyBeginAllowThreads();
13575 result = (wxInputStream *)(arg1)->GetErrorStream();
13576 wxPyEndAllowThreads(__tstate);
13577 if (PyErr_Occurred()) SWIG_fail;
13578 }
13579 {
13580 wxPyInputStream * _ptr = NULL;
13581
13582 if (result) {
13583 _ptr = new wxPyInputStream(result);
13584 }
13585 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13586 }
13587 return resultobj;
13588 fail:
13589 return NULL;
13590 }
13591
13592
13593 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13594 PyObject *resultobj = 0;
13595 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13596 wxOutputStream *result = 0 ;
13597 void *argp1 = 0 ;
13598 int res1 = 0 ;
13599 PyObject *swig_obj[1] ;
13600
13601 if (!args) SWIG_fail;
13602 swig_obj[0] = args;
13603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13604 if (!SWIG_IsOK(res1)) {
13605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13606 }
13607 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = (wxOutputStream *)(arg1)->GetOutputStream();
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13622 PyObject *resultobj = 0;
13623 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13624 void *argp1 = 0 ;
13625 int res1 = 0 ;
13626 PyObject *swig_obj[1] ;
13627
13628 if (!args) SWIG_fail;
13629 swig_obj[0] = args;
13630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13631 if (!SWIG_IsOK(res1)) {
13632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13633 }
13634 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13635 {
13636 PyThreadState* __tstate = wxPyBeginAllowThreads();
13637 (arg1)->CloseOutput();
13638 wxPyEndAllowThreads(__tstate);
13639 if (PyErr_Occurred()) SWIG_fail;
13640 }
13641 resultobj = SWIG_Py_Void();
13642 return resultobj;
13643 fail:
13644 return NULL;
13645 }
13646
13647
13648 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13649 PyObject *resultobj = 0;
13650 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13651 bool result;
13652 void *argp1 = 0 ;
13653 int res1 = 0 ;
13654 PyObject *swig_obj[1] ;
13655
13656 if (!args) SWIG_fail;
13657 swig_obj[0] = args;
13658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13659 if (!SWIG_IsOK(res1)) {
13660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13661 }
13662 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13666 wxPyEndAllowThreads(__tstate);
13667 if (PyErr_Occurred()) SWIG_fail;
13668 }
13669 {
13670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13671 }
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13679 PyObject *resultobj = 0;
13680 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13681 bool result;
13682 void *argp1 = 0 ;
13683 int res1 = 0 ;
13684 PyObject *swig_obj[1] ;
13685
13686 if (!args) SWIG_fail;
13687 swig_obj[0] = args;
13688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13689 if (!SWIG_IsOK(res1)) {
13690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13691 }
13692 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13693 {
13694 PyThreadState* __tstate = wxPyBeginAllowThreads();
13695 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13696 wxPyEndAllowThreads(__tstate);
13697 if (PyErr_Occurred()) SWIG_fail;
13698 }
13699 {
13700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13701 }
13702 return resultobj;
13703 fail:
13704 return NULL;
13705 }
13706
13707
13708 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13709 PyObject *resultobj = 0;
13710 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13711 bool result;
13712 void *argp1 = 0 ;
13713 int res1 = 0 ;
13714 PyObject *swig_obj[1] ;
13715
13716 if (!args) SWIG_fail;
13717 swig_obj[0] = args;
13718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13719 if (!SWIG_IsOK(res1)) {
13720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13721 }
13722 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13723 {
13724 PyThreadState* __tstate = wxPyBeginAllowThreads();
13725 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13726 wxPyEndAllowThreads(__tstate);
13727 if (PyErr_Occurred()) SWIG_fail;
13728 }
13729 {
13730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13731 }
13732 return resultobj;
13733 fail:
13734 return NULL;
13735 }
13736
13737
13738 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13739 PyObject *obj;
13740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13741 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13742 return SWIG_Py_Void();
13743 }
13744
13745 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13746 return SWIG_Python_InitShadowInstance(args);
13747 }
13748
13749 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13750 PyObject *resultobj = 0;
13751 int arg1 = (int) 0 ;
13752 int arg2 = (int) 0 ;
13753 int arg3 = (int) 0 ;
13754 wxProcessEvent *result = 0 ;
13755 int val1 ;
13756 int ecode1 = 0 ;
13757 int val2 ;
13758 int ecode2 = 0 ;
13759 int val3 ;
13760 int ecode3 = 0 ;
13761 PyObject * obj0 = 0 ;
13762 PyObject * obj1 = 0 ;
13763 PyObject * obj2 = 0 ;
13764 char * kwnames[] = {
13765 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13766 };
13767
13768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13769 if (obj0) {
13770 ecode1 = SWIG_AsVal_int(obj0, &val1);
13771 if (!SWIG_IsOK(ecode1)) {
13772 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13773 }
13774 arg1 = static_cast< int >(val1);
13775 }
13776 if (obj1) {
13777 ecode2 = SWIG_AsVal_int(obj1, &val2);
13778 if (!SWIG_IsOK(ecode2)) {
13779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13780 }
13781 arg2 = static_cast< int >(val2);
13782 }
13783 if (obj2) {
13784 ecode3 = SWIG_AsVal_int(obj2, &val3);
13785 if (!SWIG_IsOK(ecode3)) {
13786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13787 }
13788 arg3 = static_cast< int >(val3);
13789 }
13790 {
13791 PyThreadState* __tstate = wxPyBeginAllowThreads();
13792 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13793 wxPyEndAllowThreads(__tstate);
13794 if (PyErr_Occurred()) SWIG_fail;
13795 }
13796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13797 return resultobj;
13798 fail:
13799 return NULL;
13800 }
13801
13802
13803 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13804 PyObject *resultobj = 0;
13805 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13806 int result;
13807 void *argp1 = 0 ;
13808 int res1 = 0 ;
13809 PyObject *swig_obj[1] ;
13810
13811 if (!args) SWIG_fail;
13812 swig_obj[0] = args;
13813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13814 if (!SWIG_IsOK(res1)) {
13815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13816 }
13817 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13818 {
13819 PyThreadState* __tstate = wxPyBeginAllowThreads();
13820 result = (int)(arg1)->GetPid();
13821 wxPyEndAllowThreads(__tstate);
13822 if (PyErr_Occurred()) SWIG_fail;
13823 }
13824 resultobj = SWIG_From_int(static_cast< int >(result));
13825 return resultobj;
13826 fail:
13827 return NULL;
13828 }
13829
13830
13831 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13832 PyObject *resultobj = 0;
13833 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13834 int result;
13835 void *argp1 = 0 ;
13836 int res1 = 0 ;
13837 PyObject *swig_obj[1] ;
13838
13839 if (!args) SWIG_fail;
13840 swig_obj[0] = args;
13841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13842 if (!SWIG_IsOK(res1)) {
13843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13844 }
13845 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13846 {
13847 PyThreadState* __tstate = wxPyBeginAllowThreads();
13848 result = (int)(arg1)->GetExitCode();
13849 wxPyEndAllowThreads(__tstate);
13850 if (PyErr_Occurred()) SWIG_fail;
13851 }
13852 resultobj = SWIG_From_int(static_cast< int >(result));
13853 return resultobj;
13854 fail:
13855 return NULL;
13856 }
13857
13858
13859 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13860 PyObject *resultobj = 0;
13861 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13862 int arg2 ;
13863 void *argp1 = 0 ;
13864 int res1 = 0 ;
13865 int val2 ;
13866 int ecode2 = 0 ;
13867 PyObject *swig_obj[2] ;
13868
13869 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13871 if (!SWIG_IsOK(res1)) {
13872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13873 }
13874 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13875 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13876 if (!SWIG_IsOK(ecode2)) {
13877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13878 }
13879 arg2 = static_cast< int >(val2);
13880 if (arg1) (arg1)->m_pid = arg2;
13881
13882 resultobj = SWIG_Py_Void();
13883 return resultobj;
13884 fail:
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13890 PyObject *resultobj = 0;
13891 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13892 int result;
13893 void *argp1 = 0 ;
13894 int res1 = 0 ;
13895 PyObject *swig_obj[1] ;
13896
13897 if (!args) SWIG_fail;
13898 swig_obj[0] = args;
13899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13900 if (!SWIG_IsOK(res1)) {
13901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13902 }
13903 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13904 result = (int) ((arg1)->m_pid);
13905 resultobj = SWIG_From_int(static_cast< int >(result));
13906 return resultobj;
13907 fail:
13908 return NULL;
13909 }
13910
13911
13912 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13913 PyObject *resultobj = 0;
13914 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13915 int arg2 ;
13916 void *argp1 = 0 ;
13917 int res1 = 0 ;
13918 int val2 ;
13919 int ecode2 = 0 ;
13920 PyObject *swig_obj[2] ;
13921
13922 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13924 if (!SWIG_IsOK(res1)) {
13925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13926 }
13927 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13928 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13929 if (!SWIG_IsOK(ecode2)) {
13930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13931 }
13932 arg2 = static_cast< int >(val2);
13933 if (arg1) (arg1)->m_exitcode = arg2;
13934
13935 resultobj = SWIG_Py_Void();
13936 return resultobj;
13937 fail:
13938 return NULL;
13939 }
13940
13941
13942 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13943 PyObject *resultobj = 0;
13944 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13945 int result;
13946 void *argp1 = 0 ;
13947 int res1 = 0 ;
13948 PyObject *swig_obj[1] ;
13949
13950 if (!args) SWIG_fail;
13951 swig_obj[0] = args;
13952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13953 if (!SWIG_IsOK(res1)) {
13954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13955 }
13956 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13957 result = (int) ((arg1)->m_exitcode);
13958 resultobj = SWIG_From_int(static_cast< int >(result));
13959 return resultobj;
13960 fail:
13961 return NULL;
13962 }
13963
13964
13965 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13966 PyObject *obj;
13967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13968 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13969 return SWIG_Py_Void();
13970 }
13971
13972 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13973 return SWIG_Python_InitShadowInstance(args);
13974 }
13975
13976 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13977 PyObject *resultobj = 0;
13978 wxString *arg1 = 0 ;
13979 int arg2 = (int) wxEXEC_ASYNC ;
13980 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13981 long result;
13982 bool temp1 = false ;
13983 int val2 ;
13984 int ecode2 = 0 ;
13985 void *argp3 = 0 ;
13986 int res3 = 0 ;
13987 PyObject * obj0 = 0 ;
13988 PyObject * obj1 = 0 ;
13989 PyObject * obj2 = 0 ;
13990 char * kwnames[] = {
13991 (char *) "command",(char *) "flags",(char *) "process", NULL
13992 };
13993
13994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13995 {
13996 arg1 = wxString_in_helper(obj0);
13997 if (arg1 == NULL) SWIG_fail;
13998 temp1 = true;
13999 }
14000 if (obj1) {
14001 ecode2 = SWIG_AsVal_int(obj1, &val2);
14002 if (!SWIG_IsOK(ecode2)) {
14003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
14004 }
14005 arg2 = static_cast< int >(val2);
14006 }
14007 if (obj2) {
14008 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
14009 if (!SWIG_IsOK(res3)) {
14010 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
14011 }
14012 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
14013 }
14014 {
14015 if (!wxPyCheckForApp()) SWIG_fail;
14016 PyThreadState* __tstate = wxPyBeginAllowThreads();
14017 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
14018 wxPyEndAllowThreads(__tstate);
14019 if (PyErr_Occurred()) SWIG_fail;
14020 }
14021 resultobj = SWIG_From_long(static_cast< long >(result));
14022 {
14023 if (temp1)
14024 delete arg1;
14025 }
14026 return resultobj;
14027 fail:
14028 {
14029 if (temp1)
14030 delete arg1;
14031 }
14032 return NULL;
14033 }
14034
14035
14036 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14037 PyObject *resultobj = 0;
14038 long arg1 ;
14039 wxSignal arg2 = (wxSignal) wxSIGTERM ;
14040 wxKillError *arg3 = (wxKillError *) 0 ;
14041 int arg4 = (int) wxKILL_NOCHILDREN ;
14042 int result;
14043 long val1 ;
14044 int ecode1 = 0 ;
14045 int val2 ;
14046 int ecode2 = 0 ;
14047 wxKillError temp3 ;
14048 int val4 ;
14049 int ecode4 = 0 ;
14050 PyObject * obj0 = 0 ;
14051 PyObject * obj1 = 0 ;
14052 PyObject * obj2 = 0 ;
14053 char * kwnames[] = {
14054 (char *) "pid",(char *) "sig",(char *) "flags", NULL
14055 };
14056
14057 {
14058 arg3 = &temp3;
14059 }
14060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14061 ecode1 = SWIG_AsVal_long(obj0, &val1);
14062 if (!SWIG_IsOK(ecode1)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
14064 }
14065 arg1 = static_cast< long >(val1);
14066 if (obj1) {
14067 ecode2 = SWIG_AsVal_int(obj1, &val2);
14068 if (!SWIG_IsOK(ecode2)) {
14069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
14070 }
14071 arg2 = static_cast< wxSignal >(val2);
14072 }
14073 if (obj2) {
14074 ecode4 = SWIG_AsVal_int(obj2, &val4);
14075 if (!SWIG_IsOK(ecode4)) {
14076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
14077 }
14078 arg4 = static_cast< int >(val4);
14079 }
14080 {
14081 PyThreadState* __tstate = wxPyBeginAllowThreads();
14082 result = (int)wxKill(arg1,arg2,arg3,arg4);
14083 wxPyEndAllowThreads(__tstate);
14084 if (PyErr_Occurred()) SWIG_fail;
14085 }
14086 resultobj = SWIG_From_int(static_cast< int >(result));
14087 {
14088 PyObject* o;
14089 o = PyInt_FromLong((long) (*arg3));
14090
14091
14092
14093 resultobj = SWIG_Python_AppendOutput(resultobj, o);
14094
14095 }
14096 return resultobj;
14097 fail:
14098 return NULL;
14099 }
14100
14101
14102 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14103 PyObject *resultobj = 0;
14104 int arg1 = (int) wxJOYSTICK1 ;
14105 wxJoystick *result = 0 ;
14106 int val1 ;
14107 int ecode1 = 0 ;
14108 PyObject * obj0 = 0 ;
14109 char * kwnames[] = {
14110 (char *) "joystick", NULL
14111 };
14112
14113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
14114 if (obj0) {
14115 ecode1 = SWIG_AsVal_int(obj0, &val1);
14116 if (!SWIG_IsOK(ecode1)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
14118 }
14119 arg1 = static_cast< int >(val1);
14120 }
14121 {
14122 if (!wxPyCheckForApp()) SWIG_fail;
14123 PyThreadState* __tstate = wxPyBeginAllowThreads();
14124 result = (wxJoystick *)new wxJoystick(arg1);
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
14129 return resultobj;
14130 fail:
14131 return NULL;
14132 }
14133
14134
14135 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14136 PyObject *resultobj = 0;
14137 wxJoystick *arg1 = (wxJoystick *) 0 ;
14138 void *argp1 = 0 ;
14139 int res1 = 0 ;
14140 PyObject *swig_obj[1] ;
14141
14142 if (!args) SWIG_fail;
14143 swig_obj[0] = args;
14144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
14145 if (!SWIG_IsOK(res1)) {
14146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
14147 }
14148 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14149 {
14150 PyThreadState* __tstate = wxPyBeginAllowThreads();
14151 delete arg1;
14152
14153 wxPyEndAllowThreads(__tstate);
14154 if (PyErr_Occurred()) SWIG_fail;
14155 }
14156 resultobj = SWIG_Py_Void();
14157 return resultobj;
14158 fail:
14159 return NULL;
14160 }
14161
14162
14163 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14164 PyObject *resultobj = 0;
14165 wxJoystick *arg1 = (wxJoystick *) 0 ;
14166 wxPoint result;
14167 void *argp1 = 0 ;
14168 int res1 = 0 ;
14169 PyObject *swig_obj[1] ;
14170
14171 if (!args) SWIG_fail;
14172 swig_obj[0] = args;
14173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14174 if (!SWIG_IsOK(res1)) {
14175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14176 }
14177 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14178 {
14179 PyThreadState* __tstate = wxPyBeginAllowThreads();
14180 result = (arg1)->GetPosition();
14181 wxPyEndAllowThreads(__tstate);
14182 if (PyErr_Occurred()) SWIG_fail;
14183 }
14184 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
14185 return resultobj;
14186 fail:
14187 return NULL;
14188 }
14189
14190
14191 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14192 PyObject *resultobj = 0;
14193 wxJoystick *arg1 = (wxJoystick *) 0 ;
14194 int result;
14195 void *argp1 = 0 ;
14196 int res1 = 0 ;
14197 PyObject *swig_obj[1] ;
14198
14199 if (!args) SWIG_fail;
14200 swig_obj[0] = args;
14201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14202 if (!SWIG_IsOK(res1)) {
14203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14204 }
14205 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14206 {
14207 PyThreadState* __tstate = wxPyBeginAllowThreads();
14208 result = (int)(arg1)->GetZPosition();
14209 wxPyEndAllowThreads(__tstate);
14210 if (PyErr_Occurred()) SWIG_fail;
14211 }
14212 resultobj = SWIG_From_int(static_cast< int >(result));
14213 return resultobj;
14214 fail:
14215 return NULL;
14216 }
14217
14218
14219 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14220 PyObject *resultobj = 0;
14221 wxJoystick *arg1 = (wxJoystick *) 0 ;
14222 int result;
14223 void *argp1 = 0 ;
14224 int res1 = 0 ;
14225 PyObject *swig_obj[1] ;
14226
14227 if (!args) SWIG_fail;
14228 swig_obj[0] = args;
14229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14230 if (!SWIG_IsOK(res1)) {
14231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14232 }
14233 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14234 {
14235 PyThreadState* __tstate = wxPyBeginAllowThreads();
14236 result = (int)(arg1)->GetButtonState();
14237 wxPyEndAllowThreads(__tstate);
14238 if (PyErr_Occurred()) SWIG_fail;
14239 }
14240 resultobj = SWIG_From_int(static_cast< int >(result));
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14248 PyObject *resultobj = 0;
14249 wxJoystick *arg1 = (wxJoystick *) 0 ;
14250 int result;
14251 void *argp1 = 0 ;
14252 int res1 = 0 ;
14253 PyObject *swig_obj[1] ;
14254
14255 if (!args) SWIG_fail;
14256 swig_obj[0] = args;
14257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14258 if (!SWIG_IsOK(res1)) {
14259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14260 }
14261 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14262 {
14263 PyThreadState* __tstate = wxPyBeginAllowThreads();
14264 result = (int)(arg1)->GetPOVPosition();
14265 wxPyEndAllowThreads(__tstate);
14266 if (PyErr_Occurred()) SWIG_fail;
14267 }
14268 resultobj = SWIG_From_int(static_cast< int >(result));
14269 return resultobj;
14270 fail:
14271 return NULL;
14272 }
14273
14274
14275 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14276 PyObject *resultobj = 0;
14277 wxJoystick *arg1 = (wxJoystick *) 0 ;
14278 int result;
14279 void *argp1 = 0 ;
14280 int res1 = 0 ;
14281 PyObject *swig_obj[1] ;
14282
14283 if (!args) SWIG_fail;
14284 swig_obj[0] = args;
14285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14286 if (!SWIG_IsOK(res1)) {
14287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14288 }
14289 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14290 {
14291 PyThreadState* __tstate = wxPyBeginAllowThreads();
14292 result = (int)(arg1)->GetPOVCTSPosition();
14293 wxPyEndAllowThreads(__tstate);
14294 if (PyErr_Occurred()) SWIG_fail;
14295 }
14296 resultobj = SWIG_From_int(static_cast< int >(result));
14297 return resultobj;
14298 fail:
14299 return NULL;
14300 }
14301
14302
14303 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14304 PyObject *resultobj = 0;
14305 wxJoystick *arg1 = (wxJoystick *) 0 ;
14306 int result;
14307 void *argp1 = 0 ;
14308 int res1 = 0 ;
14309 PyObject *swig_obj[1] ;
14310
14311 if (!args) SWIG_fail;
14312 swig_obj[0] = args;
14313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14314 if (!SWIG_IsOK(res1)) {
14315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14316 }
14317 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14318 {
14319 PyThreadState* __tstate = wxPyBeginAllowThreads();
14320 result = (int)(arg1)->GetRudderPosition();
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 resultobj = SWIG_From_int(static_cast< int >(result));
14325 return resultobj;
14326 fail:
14327 return NULL;
14328 }
14329
14330
14331 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14332 PyObject *resultobj = 0;
14333 wxJoystick *arg1 = (wxJoystick *) 0 ;
14334 int result;
14335 void *argp1 = 0 ;
14336 int res1 = 0 ;
14337 PyObject *swig_obj[1] ;
14338
14339 if (!args) SWIG_fail;
14340 swig_obj[0] = args;
14341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14342 if (!SWIG_IsOK(res1)) {
14343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14344 }
14345 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14346 {
14347 PyThreadState* __tstate = wxPyBeginAllowThreads();
14348 result = (int)(arg1)->GetUPosition();
14349 wxPyEndAllowThreads(__tstate);
14350 if (PyErr_Occurred()) SWIG_fail;
14351 }
14352 resultobj = SWIG_From_int(static_cast< int >(result));
14353 return resultobj;
14354 fail:
14355 return NULL;
14356 }
14357
14358
14359 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14360 PyObject *resultobj = 0;
14361 wxJoystick *arg1 = (wxJoystick *) 0 ;
14362 int result;
14363 void *argp1 = 0 ;
14364 int res1 = 0 ;
14365 PyObject *swig_obj[1] ;
14366
14367 if (!args) SWIG_fail;
14368 swig_obj[0] = args;
14369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14370 if (!SWIG_IsOK(res1)) {
14371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14372 }
14373 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14374 {
14375 PyThreadState* __tstate = wxPyBeginAllowThreads();
14376 result = (int)(arg1)->GetVPosition();
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 resultobj = SWIG_From_int(static_cast< int >(result));
14381 return resultobj;
14382 fail:
14383 return NULL;
14384 }
14385
14386
14387 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14388 PyObject *resultobj = 0;
14389 wxJoystick *arg1 = (wxJoystick *) 0 ;
14390 int result;
14391 void *argp1 = 0 ;
14392 int res1 = 0 ;
14393 PyObject *swig_obj[1] ;
14394
14395 if (!args) SWIG_fail;
14396 swig_obj[0] = args;
14397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14398 if (!SWIG_IsOK(res1)) {
14399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14400 }
14401 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14402 {
14403 PyThreadState* __tstate = wxPyBeginAllowThreads();
14404 result = (int)(arg1)->GetMovementThreshold();
14405 wxPyEndAllowThreads(__tstate);
14406 if (PyErr_Occurred()) SWIG_fail;
14407 }
14408 resultobj = SWIG_From_int(static_cast< int >(result));
14409 return resultobj;
14410 fail:
14411 return NULL;
14412 }
14413
14414
14415 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14416 PyObject *resultobj = 0;
14417 wxJoystick *arg1 = (wxJoystick *) 0 ;
14418 int arg2 ;
14419 void *argp1 = 0 ;
14420 int res1 = 0 ;
14421 int val2 ;
14422 int ecode2 = 0 ;
14423 PyObject * obj0 = 0 ;
14424 PyObject * obj1 = 0 ;
14425 char * kwnames[] = {
14426 (char *) "self",(char *) "threshold", NULL
14427 };
14428
14429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14431 if (!SWIG_IsOK(res1)) {
14432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14433 }
14434 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14435 ecode2 = SWIG_AsVal_int(obj1, &val2);
14436 if (!SWIG_IsOK(ecode2)) {
14437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14438 }
14439 arg2 = static_cast< int >(val2);
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 (arg1)->SetMovementThreshold(arg2);
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 resultobj = SWIG_Py_Void();
14447 return resultobj;
14448 fail:
14449 return NULL;
14450 }
14451
14452
14453 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14454 PyObject *resultobj = 0;
14455 wxJoystick *arg1 = (wxJoystick *) 0 ;
14456 bool result;
14457 void *argp1 = 0 ;
14458 int res1 = 0 ;
14459 PyObject *swig_obj[1] ;
14460
14461 if (!args) SWIG_fail;
14462 swig_obj[0] = args;
14463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14464 if (!SWIG_IsOK(res1)) {
14465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14466 }
14467 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 result = (bool)(arg1)->IsOk();
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 {
14475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14476 }
14477 return resultobj;
14478 fail:
14479 return NULL;
14480 }
14481
14482
14483 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14484 PyObject *resultobj = 0;
14485 wxJoystick *arg1 = (wxJoystick *) 0 ;
14486 int result;
14487 void *argp1 = 0 ;
14488 int res1 = 0 ;
14489 PyObject *swig_obj[1] ;
14490
14491 if (!args) SWIG_fail;
14492 swig_obj[0] = args;
14493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14494 if (!SWIG_IsOK(res1)) {
14495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14496 }
14497 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 result = (int)(arg1)->GetNumberJoysticks();
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 resultobj = SWIG_From_int(static_cast< int >(result));
14505 return resultobj;
14506 fail:
14507 return NULL;
14508 }
14509
14510
14511 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14512 PyObject *resultobj = 0;
14513 wxJoystick *arg1 = (wxJoystick *) 0 ;
14514 int result;
14515 void *argp1 = 0 ;
14516 int res1 = 0 ;
14517 PyObject *swig_obj[1] ;
14518
14519 if (!args) SWIG_fail;
14520 swig_obj[0] = args;
14521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14522 if (!SWIG_IsOK(res1)) {
14523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14524 }
14525 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (int)(arg1)->GetManufacturerId();
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 resultobj = SWIG_From_int(static_cast< int >(result));
14533 return resultobj;
14534 fail:
14535 return NULL;
14536 }
14537
14538
14539 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14540 PyObject *resultobj = 0;
14541 wxJoystick *arg1 = (wxJoystick *) 0 ;
14542 int result;
14543 void *argp1 = 0 ;
14544 int res1 = 0 ;
14545 PyObject *swig_obj[1] ;
14546
14547 if (!args) SWIG_fail;
14548 swig_obj[0] = args;
14549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14550 if (!SWIG_IsOK(res1)) {
14551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14552 }
14553 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14554 {
14555 PyThreadState* __tstate = wxPyBeginAllowThreads();
14556 result = (int)(arg1)->GetProductId();
14557 wxPyEndAllowThreads(__tstate);
14558 if (PyErr_Occurred()) SWIG_fail;
14559 }
14560 resultobj = SWIG_From_int(static_cast< int >(result));
14561 return resultobj;
14562 fail:
14563 return NULL;
14564 }
14565
14566
14567 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14568 PyObject *resultobj = 0;
14569 wxJoystick *arg1 = (wxJoystick *) 0 ;
14570 wxString result;
14571 void *argp1 = 0 ;
14572 int res1 = 0 ;
14573 PyObject *swig_obj[1] ;
14574
14575 if (!args) SWIG_fail;
14576 swig_obj[0] = args;
14577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14578 if (!SWIG_IsOK(res1)) {
14579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14580 }
14581 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14582 {
14583 PyThreadState* __tstate = wxPyBeginAllowThreads();
14584 result = (arg1)->GetProductName();
14585 wxPyEndAllowThreads(__tstate);
14586 if (PyErr_Occurred()) SWIG_fail;
14587 }
14588 {
14589 #if wxUSE_UNICODE
14590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14591 #else
14592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14593 #endif
14594 }
14595 return resultobj;
14596 fail:
14597 return NULL;
14598 }
14599
14600
14601 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14602 PyObject *resultobj = 0;
14603 wxJoystick *arg1 = (wxJoystick *) 0 ;
14604 int result;
14605 void *argp1 = 0 ;
14606 int res1 = 0 ;
14607 PyObject *swig_obj[1] ;
14608
14609 if (!args) SWIG_fail;
14610 swig_obj[0] = args;
14611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14612 if (!SWIG_IsOK(res1)) {
14613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14614 }
14615 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 result = (int)(arg1)->GetXMin();
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 resultobj = SWIG_From_int(static_cast< int >(result));
14623 return resultobj;
14624 fail:
14625 return NULL;
14626 }
14627
14628
14629 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14630 PyObject *resultobj = 0;
14631 wxJoystick *arg1 = (wxJoystick *) 0 ;
14632 int result;
14633 void *argp1 = 0 ;
14634 int res1 = 0 ;
14635 PyObject *swig_obj[1] ;
14636
14637 if (!args) SWIG_fail;
14638 swig_obj[0] = args;
14639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14640 if (!SWIG_IsOK(res1)) {
14641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14642 }
14643 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 result = (int)(arg1)->GetYMin();
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 resultobj = SWIG_From_int(static_cast< int >(result));
14651 return resultobj;
14652 fail:
14653 return NULL;
14654 }
14655
14656
14657 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14658 PyObject *resultobj = 0;
14659 wxJoystick *arg1 = (wxJoystick *) 0 ;
14660 int result;
14661 void *argp1 = 0 ;
14662 int res1 = 0 ;
14663 PyObject *swig_obj[1] ;
14664
14665 if (!args) SWIG_fail;
14666 swig_obj[0] = args;
14667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14668 if (!SWIG_IsOK(res1)) {
14669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14670 }
14671 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14672 {
14673 PyThreadState* __tstate = wxPyBeginAllowThreads();
14674 result = (int)(arg1)->GetZMin();
14675 wxPyEndAllowThreads(__tstate);
14676 if (PyErr_Occurred()) SWIG_fail;
14677 }
14678 resultobj = SWIG_From_int(static_cast< int >(result));
14679 return resultobj;
14680 fail:
14681 return NULL;
14682 }
14683
14684
14685 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14686 PyObject *resultobj = 0;
14687 wxJoystick *arg1 = (wxJoystick *) 0 ;
14688 int result;
14689 void *argp1 = 0 ;
14690 int res1 = 0 ;
14691 PyObject *swig_obj[1] ;
14692
14693 if (!args) SWIG_fail;
14694 swig_obj[0] = args;
14695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14696 if (!SWIG_IsOK(res1)) {
14697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14698 }
14699 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14700 {
14701 PyThreadState* __tstate = wxPyBeginAllowThreads();
14702 result = (int)(arg1)->GetXMax();
14703 wxPyEndAllowThreads(__tstate);
14704 if (PyErr_Occurred()) SWIG_fail;
14705 }
14706 resultobj = SWIG_From_int(static_cast< int >(result));
14707 return resultobj;
14708 fail:
14709 return NULL;
14710 }
14711
14712
14713 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14714 PyObject *resultobj = 0;
14715 wxJoystick *arg1 = (wxJoystick *) 0 ;
14716 int result;
14717 void *argp1 = 0 ;
14718 int res1 = 0 ;
14719 PyObject *swig_obj[1] ;
14720
14721 if (!args) SWIG_fail;
14722 swig_obj[0] = args;
14723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14724 if (!SWIG_IsOK(res1)) {
14725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14726 }
14727 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14728 {
14729 PyThreadState* __tstate = wxPyBeginAllowThreads();
14730 result = (int)(arg1)->GetYMax();
14731 wxPyEndAllowThreads(__tstate);
14732 if (PyErr_Occurred()) SWIG_fail;
14733 }
14734 resultobj = SWIG_From_int(static_cast< int >(result));
14735 return resultobj;
14736 fail:
14737 return NULL;
14738 }
14739
14740
14741 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14742 PyObject *resultobj = 0;
14743 wxJoystick *arg1 = (wxJoystick *) 0 ;
14744 int result;
14745 void *argp1 = 0 ;
14746 int res1 = 0 ;
14747 PyObject *swig_obj[1] ;
14748
14749 if (!args) SWIG_fail;
14750 swig_obj[0] = args;
14751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14752 if (!SWIG_IsOK(res1)) {
14753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14754 }
14755 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14756 {
14757 PyThreadState* __tstate = wxPyBeginAllowThreads();
14758 result = (int)(arg1)->GetZMax();
14759 wxPyEndAllowThreads(__tstate);
14760 if (PyErr_Occurred()) SWIG_fail;
14761 }
14762 resultobj = SWIG_From_int(static_cast< int >(result));
14763 return resultobj;
14764 fail:
14765 return NULL;
14766 }
14767
14768
14769 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14770 PyObject *resultobj = 0;
14771 wxJoystick *arg1 = (wxJoystick *) 0 ;
14772 int result;
14773 void *argp1 = 0 ;
14774 int res1 = 0 ;
14775 PyObject *swig_obj[1] ;
14776
14777 if (!args) SWIG_fail;
14778 swig_obj[0] = args;
14779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14780 if (!SWIG_IsOK(res1)) {
14781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14782 }
14783 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (int)(arg1)->GetNumberButtons();
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 resultobj = SWIG_From_int(static_cast< int >(result));
14791 return resultobj;
14792 fail:
14793 return NULL;
14794 }
14795
14796
14797 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14798 PyObject *resultobj = 0;
14799 wxJoystick *arg1 = (wxJoystick *) 0 ;
14800 int 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_wxJoystick, 0 | 0 );
14808 if (!SWIG_IsOK(res1)) {
14809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14810 }
14811 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14812 {
14813 PyThreadState* __tstate = wxPyBeginAllowThreads();
14814 result = (int)(arg1)->GetNumberAxes();
14815 wxPyEndAllowThreads(__tstate);
14816 if (PyErr_Occurred()) SWIG_fail;
14817 }
14818 resultobj = SWIG_From_int(static_cast< int >(result));
14819 return resultobj;
14820 fail:
14821 return NULL;
14822 }
14823
14824
14825 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14826 PyObject *resultobj = 0;
14827 wxJoystick *arg1 = (wxJoystick *) 0 ;
14828 int result;
14829 void *argp1 = 0 ;
14830 int res1 = 0 ;
14831 PyObject *swig_obj[1] ;
14832
14833 if (!args) SWIG_fail;
14834 swig_obj[0] = args;
14835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14838 }
14839 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 result = (int)(arg1)->GetMaxButtons();
14843 wxPyEndAllowThreads(__tstate);
14844 if (PyErr_Occurred()) SWIG_fail;
14845 }
14846 resultobj = SWIG_From_int(static_cast< int >(result));
14847 return resultobj;
14848 fail:
14849 return NULL;
14850 }
14851
14852
14853 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14854 PyObject *resultobj = 0;
14855 wxJoystick *arg1 = (wxJoystick *) 0 ;
14856 int result;
14857 void *argp1 = 0 ;
14858 int res1 = 0 ;
14859 PyObject *swig_obj[1] ;
14860
14861 if (!args) SWIG_fail;
14862 swig_obj[0] = args;
14863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14864 if (!SWIG_IsOK(res1)) {
14865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14866 }
14867 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 result = (int)(arg1)->GetMaxAxes();
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 resultobj = SWIG_From_int(static_cast< int >(result));
14875 return resultobj;
14876 fail:
14877 return NULL;
14878 }
14879
14880
14881 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14882 PyObject *resultobj = 0;
14883 wxJoystick *arg1 = (wxJoystick *) 0 ;
14884 int result;
14885 void *argp1 = 0 ;
14886 int res1 = 0 ;
14887 PyObject *swig_obj[1] ;
14888
14889 if (!args) SWIG_fail;
14890 swig_obj[0] = args;
14891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14892 if (!SWIG_IsOK(res1)) {
14893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14894 }
14895 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14896 {
14897 PyThreadState* __tstate = wxPyBeginAllowThreads();
14898 result = (int)(arg1)->GetPollingMin();
14899 wxPyEndAllowThreads(__tstate);
14900 if (PyErr_Occurred()) SWIG_fail;
14901 }
14902 resultobj = SWIG_From_int(static_cast< int >(result));
14903 return resultobj;
14904 fail:
14905 return NULL;
14906 }
14907
14908
14909 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14910 PyObject *resultobj = 0;
14911 wxJoystick *arg1 = (wxJoystick *) 0 ;
14912 int result;
14913 void *argp1 = 0 ;
14914 int res1 = 0 ;
14915 PyObject *swig_obj[1] ;
14916
14917 if (!args) SWIG_fail;
14918 swig_obj[0] = args;
14919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14920 if (!SWIG_IsOK(res1)) {
14921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14922 }
14923 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14924 {
14925 PyThreadState* __tstate = wxPyBeginAllowThreads();
14926 result = (int)(arg1)->GetPollingMax();
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 resultobj = SWIG_From_int(static_cast< int >(result));
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14938 PyObject *resultobj = 0;
14939 wxJoystick *arg1 = (wxJoystick *) 0 ;
14940 int result;
14941 void *argp1 = 0 ;
14942 int res1 = 0 ;
14943 PyObject *swig_obj[1] ;
14944
14945 if (!args) SWIG_fail;
14946 swig_obj[0] = args;
14947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14948 if (!SWIG_IsOK(res1)) {
14949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14950 }
14951 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 result = (int)(arg1)->GetRudderMin();
14955 wxPyEndAllowThreads(__tstate);
14956 if (PyErr_Occurred()) SWIG_fail;
14957 }
14958 resultobj = SWIG_From_int(static_cast< int >(result));
14959 return resultobj;
14960 fail:
14961 return NULL;
14962 }
14963
14964
14965 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14966 PyObject *resultobj = 0;
14967 wxJoystick *arg1 = (wxJoystick *) 0 ;
14968 int result;
14969 void *argp1 = 0 ;
14970 int res1 = 0 ;
14971 PyObject *swig_obj[1] ;
14972
14973 if (!args) SWIG_fail;
14974 swig_obj[0] = args;
14975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14976 if (!SWIG_IsOK(res1)) {
14977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14978 }
14979 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = (int)(arg1)->GetRudderMax();
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 resultobj = SWIG_From_int(static_cast< int >(result));
14987 return resultobj;
14988 fail:
14989 return NULL;
14990 }
14991
14992
14993 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14994 PyObject *resultobj = 0;
14995 wxJoystick *arg1 = (wxJoystick *) 0 ;
14996 int result;
14997 void *argp1 = 0 ;
14998 int res1 = 0 ;
14999 PyObject *swig_obj[1] ;
15000
15001 if (!args) SWIG_fail;
15002 swig_obj[0] = args;
15003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15004 if (!SWIG_IsOK(res1)) {
15005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15006 }
15007 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15008 {
15009 PyThreadState* __tstate = wxPyBeginAllowThreads();
15010 result = (int)(arg1)->GetUMin();
15011 wxPyEndAllowThreads(__tstate);
15012 if (PyErr_Occurred()) SWIG_fail;
15013 }
15014 resultobj = SWIG_From_int(static_cast< int >(result));
15015 return resultobj;
15016 fail:
15017 return NULL;
15018 }
15019
15020
15021 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15022 PyObject *resultobj = 0;
15023 wxJoystick *arg1 = (wxJoystick *) 0 ;
15024 int result;
15025 void *argp1 = 0 ;
15026 int res1 = 0 ;
15027 PyObject *swig_obj[1] ;
15028
15029 if (!args) SWIG_fail;
15030 swig_obj[0] = args;
15031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15032 if (!SWIG_IsOK(res1)) {
15033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15034 }
15035 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15036 {
15037 PyThreadState* __tstate = wxPyBeginAllowThreads();
15038 result = (int)(arg1)->GetUMax();
15039 wxPyEndAllowThreads(__tstate);
15040 if (PyErr_Occurred()) SWIG_fail;
15041 }
15042 resultobj = SWIG_From_int(static_cast< int >(result));
15043 return resultobj;
15044 fail:
15045 return NULL;
15046 }
15047
15048
15049 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15050 PyObject *resultobj = 0;
15051 wxJoystick *arg1 = (wxJoystick *) 0 ;
15052 int result;
15053 void *argp1 = 0 ;
15054 int res1 = 0 ;
15055 PyObject *swig_obj[1] ;
15056
15057 if (!args) SWIG_fail;
15058 swig_obj[0] = args;
15059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15060 if (!SWIG_IsOK(res1)) {
15061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
15062 }
15063 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15064 {
15065 PyThreadState* __tstate = wxPyBeginAllowThreads();
15066 result = (int)(arg1)->GetVMin();
15067 wxPyEndAllowThreads(__tstate);
15068 if (PyErr_Occurred()) SWIG_fail;
15069 }
15070 resultobj = SWIG_From_int(static_cast< int >(result));
15071 return resultobj;
15072 fail:
15073 return NULL;
15074 }
15075
15076
15077 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15078 PyObject *resultobj = 0;
15079 wxJoystick *arg1 = (wxJoystick *) 0 ;
15080 int result;
15081 void *argp1 = 0 ;
15082 int res1 = 0 ;
15083 PyObject *swig_obj[1] ;
15084
15085 if (!args) SWIG_fail;
15086 swig_obj[0] = args;
15087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15088 if (!SWIG_IsOK(res1)) {
15089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
15090 }
15091 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 result = (int)(arg1)->GetVMax();
15095 wxPyEndAllowThreads(__tstate);
15096 if (PyErr_Occurred()) SWIG_fail;
15097 }
15098 resultobj = SWIG_From_int(static_cast< int >(result));
15099 return resultobj;
15100 fail:
15101 return NULL;
15102 }
15103
15104
15105 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15106 PyObject *resultobj = 0;
15107 wxJoystick *arg1 = (wxJoystick *) 0 ;
15108 bool result;
15109 void *argp1 = 0 ;
15110 int res1 = 0 ;
15111 PyObject *swig_obj[1] ;
15112
15113 if (!args) SWIG_fail;
15114 swig_obj[0] = args;
15115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15116 if (!SWIG_IsOK(res1)) {
15117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
15118 }
15119 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15120 {
15121 PyThreadState* __tstate = wxPyBeginAllowThreads();
15122 result = (bool)(arg1)->HasRudder();
15123 wxPyEndAllowThreads(__tstate);
15124 if (PyErr_Occurred()) SWIG_fail;
15125 }
15126 {
15127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15128 }
15129 return resultobj;
15130 fail:
15131 return NULL;
15132 }
15133
15134
15135 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15136 PyObject *resultobj = 0;
15137 wxJoystick *arg1 = (wxJoystick *) 0 ;
15138 bool result;
15139 void *argp1 = 0 ;
15140 int res1 = 0 ;
15141 PyObject *swig_obj[1] ;
15142
15143 if (!args) SWIG_fail;
15144 swig_obj[0] = args;
15145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15146 if (!SWIG_IsOK(res1)) {
15147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
15148 }
15149 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (bool)(arg1)->HasZ();
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 {
15157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15158 }
15159 return resultobj;
15160 fail:
15161 return NULL;
15162 }
15163
15164
15165 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15166 PyObject *resultobj = 0;
15167 wxJoystick *arg1 = (wxJoystick *) 0 ;
15168 bool result;
15169 void *argp1 = 0 ;
15170 int res1 = 0 ;
15171 PyObject *swig_obj[1] ;
15172
15173 if (!args) SWIG_fail;
15174 swig_obj[0] = args;
15175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15176 if (!SWIG_IsOK(res1)) {
15177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
15178 }
15179 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (bool)(arg1)->HasU();
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 {
15187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15188 }
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15196 PyObject *resultobj = 0;
15197 wxJoystick *arg1 = (wxJoystick *) 0 ;
15198 bool result;
15199 void *argp1 = 0 ;
15200 int res1 = 0 ;
15201 PyObject *swig_obj[1] ;
15202
15203 if (!args) SWIG_fail;
15204 swig_obj[0] = args;
15205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15208 }
15209 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15210 {
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 result = (bool)(arg1)->HasV();
15213 wxPyEndAllowThreads(__tstate);
15214 if (PyErr_Occurred()) SWIG_fail;
15215 }
15216 {
15217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15218 }
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15226 PyObject *resultobj = 0;
15227 wxJoystick *arg1 = (wxJoystick *) 0 ;
15228 bool result;
15229 void *argp1 = 0 ;
15230 int res1 = 0 ;
15231 PyObject *swig_obj[1] ;
15232
15233 if (!args) SWIG_fail;
15234 swig_obj[0] = args;
15235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15236 if (!SWIG_IsOK(res1)) {
15237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15238 }
15239 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 result = (bool)(arg1)->HasPOV();
15243 wxPyEndAllowThreads(__tstate);
15244 if (PyErr_Occurred()) SWIG_fail;
15245 }
15246 {
15247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15248 }
15249 return resultobj;
15250 fail:
15251 return NULL;
15252 }
15253
15254
15255 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15256 PyObject *resultobj = 0;
15257 wxJoystick *arg1 = (wxJoystick *) 0 ;
15258 bool result;
15259 void *argp1 = 0 ;
15260 int res1 = 0 ;
15261 PyObject *swig_obj[1] ;
15262
15263 if (!args) SWIG_fail;
15264 swig_obj[0] = args;
15265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15266 if (!SWIG_IsOK(res1)) {
15267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15268 }
15269 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15270 {
15271 PyThreadState* __tstate = wxPyBeginAllowThreads();
15272 result = (bool)(arg1)->HasPOV4Dir();
15273 wxPyEndAllowThreads(__tstate);
15274 if (PyErr_Occurred()) SWIG_fail;
15275 }
15276 {
15277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15278 }
15279 return resultobj;
15280 fail:
15281 return NULL;
15282 }
15283
15284
15285 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15286 PyObject *resultobj = 0;
15287 wxJoystick *arg1 = (wxJoystick *) 0 ;
15288 bool result;
15289 void *argp1 = 0 ;
15290 int res1 = 0 ;
15291 PyObject *swig_obj[1] ;
15292
15293 if (!args) SWIG_fail;
15294 swig_obj[0] = args;
15295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15296 if (!SWIG_IsOK(res1)) {
15297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15298 }
15299 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15300 {
15301 PyThreadState* __tstate = wxPyBeginAllowThreads();
15302 result = (bool)(arg1)->HasPOVCTS();
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 {
15307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15308 }
15309 return resultobj;
15310 fail:
15311 return NULL;
15312 }
15313
15314
15315 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15316 PyObject *resultobj = 0;
15317 wxJoystick *arg1 = (wxJoystick *) 0 ;
15318 wxWindow *arg2 = (wxWindow *) 0 ;
15319 int arg3 = (int) 0 ;
15320 bool result;
15321 void *argp1 = 0 ;
15322 int res1 = 0 ;
15323 void *argp2 = 0 ;
15324 int res2 = 0 ;
15325 int val3 ;
15326 int ecode3 = 0 ;
15327 PyObject * obj0 = 0 ;
15328 PyObject * obj1 = 0 ;
15329 PyObject * obj2 = 0 ;
15330 char * kwnames[] = {
15331 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15332 };
15333
15334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15336 if (!SWIG_IsOK(res1)) {
15337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15338 }
15339 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15341 if (!SWIG_IsOK(res2)) {
15342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15343 }
15344 arg2 = reinterpret_cast< wxWindow * >(argp2);
15345 if (obj2) {
15346 ecode3 = SWIG_AsVal_int(obj2, &val3);
15347 if (!SWIG_IsOK(ecode3)) {
15348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15349 }
15350 arg3 = static_cast< int >(val3);
15351 }
15352 {
15353 PyThreadState* __tstate = wxPyBeginAllowThreads();
15354 result = (bool)(arg1)->SetCapture(arg2,arg3);
15355 wxPyEndAllowThreads(__tstate);
15356 if (PyErr_Occurred()) SWIG_fail;
15357 }
15358 {
15359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15360 }
15361 return resultobj;
15362 fail:
15363 return NULL;
15364 }
15365
15366
15367 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15368 PyObject *resultobj = 0;
15369 wxJoystick *arg1 = (wxJoystick *) 0 ;
15370 bool result;
15371 void *argp1 = 0 ;
15372 int res1 = 0 ;
15373 PyObject *swig_obj[1] ;
15374
15375 if (!args) SWIG_fail;
15376 swig_obj[0] = args;
15377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15378 if (!SWIG_IsOK(res1)) {
15379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15380 }
15381 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15382 {
15383 PyThreadState* __tstate = wxPyBeginAllowThreads();
15384 result = (bool)(arg1)->ReleaseCapture();
15385 wxPyEndAllowThreads(__tstate);
15386 if (PyErr_Occurred()) SWIG_fail;
15387 }
15388 {
15389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15390 }
15391 return resultobj;
15392 fail:
15393 return NULL;
15394 }
15395
15396
15397 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15398 PyObject *obj;
15399 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15400 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15401 return SWIG_Py_Void();
15402 }
15403
15404 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15405 return SWIG_Python_InitShadowInstance(args);
15406 }
15407
15408 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15409 PyObject *resultobj = 0;
15410 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15411 int arg2 = (int) 0 ;
15412 int arg3 = (int) wxJOYSTICK1 ;
15413 int arg4 = (int) 0 ;
15414 wxJoystickEvent *result = 0 ;
15415 int val1 ;
15416 int ecode1 = 0 ;
15417 int val2 ;
15418 int ecode2 = 0 ;
15419 int val3 ;
15420 int ecode3 = 0 ;
15421 int val4 ;
15422 int ecode4 = 0 ;
15423 PyObject * obj0 = 0 ;
15424 PyObject * obj1 = 0 ;
15425 PyObject * obj2 = 0 ;
15426 PyObject * obj3 = 0 ;
15427 char * kwnames[] = {
15428 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15429 };
15430
15431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15432 if (obj0) {
15433 ecode1 = SWIG_AsVal_int(obj0, &val1);
15434 if (!SWIG_IsOK(ecode1)) {
15435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15436 }
15437 arg1 = static_cast< wxEventType >(val1);
15438 }
15439 if (obj1) {
15440 ecode2 = SWIG_AsVal_int(obj1, &val2);
15441 if (!SWIG_IsOK(ecode2)) {
15442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15443 }
15444 arg2 = static_cast< int >(val2);
15445 }
15446 if (obj2) {
15447 ecode3 = SWIG_AsVal_int(obj2, &val3);
15448 if (!SWIG_IsOK(ecode3)) {
15449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15450 }
15451 arg3 = static_cast< int >(val3);
15452 }
15453 if (obj3) {
15454 ecode4 = SWIG_AsVal_int(obj3, &val4);
15455 if (!SWIG_IsOK(ecode4)) {
15456 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15457 }
15458 arg4 = static_cast< int >(val4);
15459 }
15460 {
15461 PyThreadState* __tstate = wxPyBeginAllowThreads();
15462 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15463 wxPyEndAllowThreads(__tstate);
15464 if (PyErr_Occurred()) SWIG_fail;
15465 }
15466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15467 return resultobj;
15468 fail:
15469 return NULL;
15470 }
15471
15472
15473 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15474 PyObject *resultobj = 0;
15475 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15476 wxPoint result;
15477 void *argp1 = 0 ;
15478 int res1 = 0 ;
15479 PyObject *swig_obj[1] ;
15480
15481 if (!args) SWIG_fail;
15482 swig_obj[0] = args;
15483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15484 if (!SWIG_IsOK(res1)) {
15485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15486 }
15487 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15488 {
15489 PyThreadState* __tstate = wxPyBeginAllowThreads();
15490 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15491 wxPyEndAllowThreads(__tstate);
15492 if (PyErr_Occurred()) SWIG_fail;
15493 }
15494 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15495 return resultobj;
15496 fail:
15497 return NULL;
15498 }
15499
15500
15501 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15502 PyObject *resultobj = 0;
15503 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15504 int result;
15505 void *argp1 = 0 ;
15506 int res1 = 0 ;
15507 PyObject *swig_obj[1] ;
15508
15509 if (!args) SWIG_fail;
15510 swig_obj[0] = args;
15511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15512 if (!SWIG_IsOK(res1)) {
15513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15514 }
15515 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15516 {
15517 PyThreadState* __tstate = wxPyBeginAllowThreads();
15518 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15519 wxPyEndAllowThreads(__tstate);
15520 if (PyErr_Occurred()) SWIG_fail;
15521 }
15522 resultobj = SWIG_From_int(static_cast< int >(result));
15523 return resultobj;
15524 fail:
15525 return NULL;
15526 }
15527
15528
15529 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15530 PyObject *resultobj = 0;
15531 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15532 int result;
15533 void *argp1 = 0 ;
15534 int res1 = 0 ;
15535 PyObject *swig_obj[1] ;
15536
15537 if (!args) SWIG_fail;
15538 swig_obj[0] = args;
15539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15540 if (!SWIG_IsOK(res1)) {
15541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15542 }
15543 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15544 {
15545 PyThreadState* __tstate = wxPyBeginAllowThreads();
15546 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 resultobj = SWIG_From_int(static_cast< int >(result));
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15558 PyObject *resultobj = 0;
15559 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15560 int result;
15561 void *argp1 = 0 ;
15562 int res1 = 0 ;
15563 PyObject *swig_obj[1] ;
15564
15565 if (!args) SWIG_fail;
15566 swig_obj[0] = args;
15567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15570 }
15571 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15572 {
15573 PyThreadState* __tstate = wxPyBeginAllowThreads();
15574 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15575 wxPyEndAllowThreads(__tstate);
15576 if (PyErr_Occurred()) SWIG_fail;
15577 }
15578 resultobj = SWIG_From_int(static_cast< int >(result));
15579 return resultobj;
15580 fail:
15581 return NULL;
15582 }
15583
15584
15585 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15586 PyObject *resultobj = 0;
15587 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15588 int result;
15589 void *argp1 = 0 ;
15590 int res1 = 0 ;
15591 PyObject *swig_obj[1] ;
15592
15593 if (!args) SWIG_fail;
15594 swig_obj[0] = args;
15595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15596 if (!SWIG_IsOK(res1)) {
15597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15598 }
15599 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15603 wxPyEndAllowThreads(__tstate);
15604 if (PyErr_Occurred()) SWIG_fail;
15605 }
15606 resultobj = SWIG_From_int(static_cast< int >(result));
15607 return resultobj;
15608 fail:
15609 return NULL;
15610 }
15611
15612
15613 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15614 PyObject *resultobj = 0;
15615 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15616 int arg2 ;
15617 void *argp1 = 0 ;
15618 int res1 = 0 ;
15619 int val2 ;
15620 int ecode2 = 0 ;
15621 PyObject * obj0 = 0 ;
15622 PyObject * obj1 = 0 ;
15623 char * kwnames[] = {
15624 (char *) "self",(char *) "stick", NULL
15625 };
15626
15627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15629 if (!SWIG_IsOK(res1)) {
15630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15631 }
15632 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15633 ecode2 = SWIG_AsVal_int(obj1, &val2);
15634 if (!SWIG_IsOK(ecode2)) {
15635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15636 }
15637 arg2 = static_cast< int >(val2);
15638 {
15639 PyThreadState* __tstate = wxPyBeginAllowThreads();
15640 (arg1)->SetJoystick(arg2);
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 resultobj = SWIG_Py_Void();
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15652 PyObject *resultobj = 0;
15653 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15654 int arg2 ;
15655 void *argp1 = 0 ;
15656 int res1 = 0 ;
15657 int val2 ;
15658 int ecode2 = 0 ;
15659 PyObject * obj0 = 0 ;
15660 PyObject * obj1 = 0 ;
15661 char * kwnames[] = {
15662 (char *) "self",(char *) "state", NULL
15663 };
15664
15665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15667 if (!SWIG_IsOK(res1)) {
15668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15669 }
15670 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15671 ecode2 = SWIG_AsVal_int(obj1, &val2);
15672 if (!SWIG_IsOK(ecode2)) {
15673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15674 }
15675 arg2 = static_cast< int >(val2);
15676 {
15677 PyThreadState* __tstate = wxPyBeginAllowThreads();
15678 (arg1)->SetButtonState(arg2);
15679 wxPyEndAllowThreads(__tstate);
15680 if (PyErr_Occurred()) SWIG_fail;
15681 }
15682 resultobj = SWIG_Py_Void();
15683 return resultobj;
15684 fail:
15685 return NULL;
15686 }
15687
15688
15689 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15690 PyObject *resultobj = 0;
15691 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15692 int arg2 ;
15693 void *argp1 = 0 ;
15694 int res1 = 0 ;
15695 int val2 ;
15696 int ecode2 = 0 ;
15697 PyObject * obj0 = 0 ;
15698 PyObject * obj1 = 0 ;
15699 char * kwnames[] = {
15700 (char *) "self",(char *) "change", NULL
15701 };
15702
15703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15705 if (!SWIG_IsOK(res1)) {
15706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15707 }
15708 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15709 ecode2 = SWIG_AsVal_int(obj1, &val2);
15710 if (!SWIG_IsOK(ecode2)) {
15711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15712 }
15713 arg2 = static_cast< int >(val2);
15714 {
15715 PyThreadState* __tstate = wxPyBeginAllowThreads();
15716 (arg1)->SetButtonChange(arg2);
15717 wxPyEndAllowThreads(__tstate);
15718 if (PyErr_Occurred()) SWIG_fail;
15719 }
15720 resultobj = SWIG_Py_Void();
15721 return resultobj;
15722 fail:
15723 return NULL;
15724 }
15725
15726
15727 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15728 PyObject *resultobj = 0;
15729 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15730 wxPoint *arg2 = 0 ;
15731 void *argp1 = 0 ;
15732 int res1 = 0 ;
15733 wxPoint temp2 ;
15734 PyObject * obj0 = 0 ;
15735 PyObject * obj1 = 0 ;
15736 char * kwnames[] = {
15737 (char *) "self",(char *) "pos", NULL
15738 };
15739
15740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15742 if (!SWIG_IsOK(res1)) {
15743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15744 }
15745 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15746 {
15747 arg2 = &temp2;
15748 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15749 }
15750 {
15751 PyThreadState* __tstate = wxPyBeginAllowThreads();
15752 (arg1)->SetPosition((wxPoint const &)*arg2);
15753 wxPyEndAllowThreads(__tstate);
15754 if (PyErr_Occurred()) SWIG_fail;
15755 }
15756 resultobj = SWIG_Py_Void();
15757 return resultobj;
15758 fail:
15759 return NULL;
15760 }
15761
15762
15763 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15764 PyObject *resultobj = 0;
15765 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15766 int arg2 ;
15767 void *argp1 = 0 ;
15768 int res1 = 0 ;
15769 int val2 ;
15770 int ecode2 = 0 ;
15771 PyObject * obj0 = 0 ;
15772 PyObject * obj1 = 0 ;
15773 char * kwnames[] = {
15774 (char *) "self",(char *) "zPos", NULL
15775 };
15776
15777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15779 if (!SWIG_IsOK(res1)) {
15780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15781 }
15782 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15783 ecode2 = SWIG_AsVal_int(obj1, &val2);
15784 if (!SWIG_IsOK(ecode2)) {
15785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15786 }
15787 arg2 = static_cast< int >(val2);
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 (arg1)->SetZPosition(arg2);
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 resultobj = SWIG_Py_Void();
15795 return resultobj;
15796 fail:
15797 return NULL;
15798 }
15799
15800
15801 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15802 PyObject *resultobj = 0;
15803 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15804 bool result;
15805 void *argp1 = 0 ;
15806 int res1 = 0 ;
15807 PyObject *swig_obj[1] ;
15808
15809 if (!args) SWIG_fail;
15810 swig_obj[0] = args;
15811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15814 }
15815 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 {
15823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15824 }
15825 return resultobj;
15826 fail:
15827 return NULL;
15828 }
15829
15830
15831 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15832 PyObject *resultobj = 0;
15833 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15834 bool result;
15835 void *argp1 = 0 ;
15836 int res1 = 0 ;
15837 PyObject *swig_obj[1] ;
15838
15839 if (!args) SWIG_fail;
15840 swig_obj[0] = args;
15841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15842 if (!SWIG_IsOK(res1)) {
15843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15844 }
15845 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15846 {
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15849 wxPyEndAllowThreads(__tstate);
15850 if (PyErr_Occurred()) SWIG_fail;
15851 }
15852 {
15853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15854 }
15855 return resultobj;
15856 fail:
15857 return NULL;
15858 }
15859
15860
15861 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15862 PyObject *resultobj = 0;
15863 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15864 bool result;
15865 void *argp1 = 0 ;
15866 int res1 = 0 ;
15867 PyObject *swig_obj[1] ;
15868
15869 if (!args) SWIG_fail;
15870 swig_obj[0] = args;
15871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15872 if (!SWIG_IsOK(res1)) {
15873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15874 }
15875 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15876 {
15877 PyThreadState* __tstate = wxPyBeginAllowThreads();
15878 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15879 wxPyEndAllowThreads(__tstate);
15880 if (PyErr_Occurred()) SWIG_fail;
15881 }
15882 {
15883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15884 }
15885 return resultobj;
15886 fail:
15887 return NULL;
15888 }
15889
15890
15891 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15892 PyObject *resultobj = 0;
15893 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15894 int arg2 = (int) wxJOY_BUTTON_ANY ;
15895 bool result;
15896 void *argp1 = 0 ;
15897 int res1 = 0 ;
15898 int val2 ;
15899 int ecode2 = 0 ;
15900 PyObject * obj0 = 0 ;
15901 PyObject * obj1 = 0 ;
15902 char * kwnames[] = {
15903 (char *) "self",(char *) "but", NULL
15904 };
15905
15906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15908 if (!SWIG_IsOK(res1)) {
15909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15910 }
15911 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15912 if (obj1) {
15913 ecode2 = SWIG_AsVal_int(obj1, &val2);
15914 if (!SWIG_IsOK(ecode2)) {
15915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15916 }
15917 arg2 = static_cast< int >(val2);
15918 }
15919 {
15920 PyThreadState* __tstate = wxPyBeginAllowThreads();
15921 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15922 wxPyEndAllowThreads(__tstate);
15923 if (PyErr_Occurred()) SWIG_fail;
15924 }
15925 {
15926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15927 }
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15935 PyObject *resultobj = 0;
15936 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15937 int arg2 = (int) wxJOY_BUTTON_ANY ;
15938 bool result;
15939 void *argp1 = 0 ;
15940 int res1 = 0 ;
15941 int val2 ;
15942 int ecode2 = 0 ;
15943 PyObject * obj0 = 0 ;
15944 PyObject * obj1 = 0 ;
15945 char * kwnames[] = {
15946 (char *) "self",(char *) "but", NULL
15947 };
15948
15949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15951 if (!SWIG_IsOK(res1)) {
15952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15953 }
15954 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15955 if (obj1) {
15956 ecode2 = SWIG_AsVal_int(obj1, &val2);
15957 if (!SWIG_IsOK(ecode2)) {
15958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15959 }
15960 arg2 = static_cast< int >(val2);
15961 }
15962 {
15963 PyThreadState* __tstate = wxPyBeginAllowThreads();
15964 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15965 wxPyEndAllowThreads(__tstate);
15966 if (PyErr_Occurred()) SWIG_fail;
15967 }
15968 {
15969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15970 }
15971 return resultobj;
15972 fail:
15973 return NULL;
15974 }
15975
15976
15977 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15978 PyObject *resultobj = 0;
15979 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15980 int arg2 = (int) wxJOY_BUTTON_ANY ;
15981 bool result;
15982 void *argp1 = 0 ;
15983 int res1 = 0 ;
15984 int val2 ;
15985 int ecode2 = 0 ;
15986 PyObject * obj0 = 0 ;
15987 PyObject * obj1 = 0 ;
15988 char * kwnames[] = {
15989 (char *) "self",(char *) "but", NULL
15990 };
15991
15992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15994 if (!SWIG_IsOK(res1)) {
15995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15996 }
15997 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15998 if (obj1) {
15999 ecode2 = SWIG_AsVal_int(obj1, &val2);
16000 if (!SWIG_IsOK(ecode2)) {
16001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
16002 }
16003 arg2 = static_cast< int >(val2);
16004 }
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 {
16012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16013 }
16014 return resultobj;
16015 fail:
16016 return NULL;
16017 }
16018
16019
16020 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16021 PyObject *obj;
16022 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16023 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
16024 return SWIG_Py_Void();
16025 }
16026
16027 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16028 return SWIG_Python_InitShadowInstance(args);
16029 }
16030
16031 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16032 PyObject *resultobj = 0;
16033 wxString const &arg1_defvalue = wxPyEmptyString ;
16034 wxString *arg1 = (wxString *) &arg1_defvalue ;
16035 wxSound *result = 0 ;
16036 bool temp1 = false ;
16037 PyObject * obj0 = 0 ;
16038 char * kwnames[] = {
16039 (char *) "fileName", NULL
16040 };
16041
16042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
16043 if (obj0) {
16044 {
16045 arg1 = wxString_in_helper(obj0);
16046 if (arg1 == NULL) SWIG_fail;
16047 temp1 = true;
16048 }
16049 }
16050 {
16051 if (!wxPyCheckForApp()) SWIG_fail;
16052 PyThreadState* __tstate = wxPyBeginAllowThreads();
16053 result = (wxSound *)new_wxSound((wxString const &)*arg1);
16054 wxPyEndAllowThreads(__tstate);
16055 if (PyErr_Occurred()) SWIG_fail;
16056 }
16057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
16058 {
16059 if (temp1)
16060 delete arg1;
16061 }
16062 return resultobj;
16063 fail:
16064 {
16065 if (temp1)
16066 delete arg1;
16067 }
16068 return NULL;
16069 }
16070
16071
16072 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16073 PyObject *resultobj = 0;
16074 PyObject *arg1 = (PyObject *) 0 ;
16075 wxSound *result = 0 ;
16076 PyObject * obj0 = 0 ;
16077 char * kwnames[] = {
16078 (char *) "data", NULL
16079 };
16080
16081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
16082 arg1 = obj0;
16083 {
16084 if (!wxPyCheckForApp()) SWIG_fail;
16085 PyThreadState* __tstate = wxPyBeginAllowThreads();
16086 result = (wxSound *)new_wxSound(arg1);
16087 wxPyEndAllowThreads(__tstate);
16088 if (PyErr_Occurred()) SWIG_fail;
16089 }
16090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
16091 return resultobj;
16092 fail:
16093 return NULL;
16094 }
16095
16096
16097 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16098 PyObject *resultobj = 0;
16099 wxSound *arg1 = (wxSound *) 0 ;
16100 void *argp1 = 0 ;
16101 int res1 = 0 ;
16102 PyObject *swig_obj[1] ;
16103
16104 if (!args) SWIG_fail;
16105 swig_obj[0] = args;
16106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
16107 if (!SWIG_IsOK(res1)) {
16108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
16109 }
16110 arg1 = reinterpret_cast< wxSound * >(argp1);
16111 {
16112 PyThreadState* __tstate = wxPyBeginAllowThreads();
16113 delete arg1;
16114
16115 wxPyEndAllowThreads(__tstate);
16116 if (PyErr_Occurred()) SWIG_fail;
16117 }
16118 resultobj = SWIG_Py_Void();
16119 return resultobj;
16120 fail:
16121 return NULL;
16122 }
16123
16124
16125 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16126 PyObject *resultobj = 0;
16127 wxSound *arg1 = (wxSound *) 0 ;
16128 wxString *arg2 = 0 ;
16129 bool result;
16130 void *argp1 = 0 ;
16131 int res1 = 0 ;
16132 bool temp2 = false ;
16133 PyObject * obj0 = 0 ;
16134 PyObject * obj1 = 0 ;
16135 char * kwnames[] = {
16136 (char *) "self",(char *) "fileName", NULL
16137 };
16138
16139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
16140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16141 if (!SWIG_IsOK(res1)) {
16142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
16143 }
16144 arg1 = reinterpret_cast< wxSound * >(argp1);
16145 {
16146 arg2 = wxString_in_helper(obj1);
16147 if (arg2 == NULL) SWIG_fail;
16148 temp2 = true;
16149 }
16150 {
16151 PyThreadState* __tstate = wxPyBeginAllowThreads();
16152 result = (bool)(arg1)->Create((wxString const &)*arg2);
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 {
16157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16158 }
16159 {
16160 if (temp2)
16161 delete arg2;
16162 }
16163 return resultobj;
16164 fail:
16165 {
16166 if (temp2)
16167 delete arg2;
16168 }
16169 return NULL;
16170 }
16171
16172
16173 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16174 PyObject *resultobj = 0;
16175 wxSound *arg1 = (wxSound *) 0 ;
16176 PyObject *arg2 = (PyObject *) 0 ;
16177 bool result;
16178 void *argp1 = 0 ;
16179 int res1 = 0 ;
16180 PyObject * obj0 = 0 ;
16181 PyObject * obj1 = 0 ;
16182 char * kwnames[] = {
16183 (char *) "self",(char *) "data", NULL
16184 };
16185
16186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
16187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
16190 }
16191 arg1 = reinterpret_cast< wxSound * >(argp1);
16192 arg2 = obj1;
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 result = (bool)wxSound_CreateFromData(arg1,arg2);
16196 wxPyEndAllowThreads(__tstate);
16197 if (PyErr_Occurred()) SWIG_fail;
16198 }
16199 {
16200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16201 }
16202 return resultobj;
16203 fail:
16204 return NULL;
16205 }
16206
16207
16208 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16209 PyObject *resultobj = 0;
16210 wxSound *arg1 = (wxSound *) 0 ;
16211 bool result;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 PyObject *swig_obj[1] ;
16215
16216 if (!args) SWIG_fail;
16217 swig_obj[0] = args;
16218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16219 if (!SWIG_IsOK(res1)) {
16220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16221 }
16222 arg1 = reinterpret_cast< wxSound * >(argp1);
16223 {
16224 PyThreadState* __tstate = wxPyBeginAllowThreads();
16225 result = (bool)(arg1)->IsOk();
16226 wxPyEndAllowThreads(__tstate);
16227 if (PyErr_Occurred()) SWIG_fail;
16228 }
16229 {
16230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16231 }
16232 return resultobj;
16233 fail:
16234 return NULL;
16235 }
16236
16237
16238 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16239 PyObject *resultobj = 0;
16240 wxSound *arg1 = (wxSound *) 0 ;
16241 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16242 bool result;
16243 void *argp1 = 0 ;
16244 int res1 = 0 ;
16245 unsigned int val2 ;
16246 int ecode2 = 0 ;
16247 PyObject * obj0 = 0 ;
16248 PyObject * obj1 = 0 ;
16249 char * kwnames[] = {
16250 (char *) "self",(char *) "flags", NULL
16251 };
16252
16253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16255 if (!SWIG_IsOK(res1)) {
16256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16257 }
16258 arg1 = reinterpret_cast< wxSound * >(argp1);
16259 if (obj1) {
16260 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16261 if (!SWIG_IsOK(ecode2)) {
16262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16263 }
16264 arg2 = static_cast< unsigned int >(val2);
16265 }
16266 {
16267 if (!wxPyCheckForApp()) SWIG_fail;
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (bool)((wxSound const *)arg1)->Play(arg2);
16270 wxPyEndAllowThreads(__tstate);
16271 if (PyErr_Occurred()) SWIG_fail;
16272 }
16273 {
16274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16275 }
16276 return resultobj;
16277 fail:
16278 return NULL;
16279 }
16280
16281
16282 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16283 PyObject *resultobj = 0;
16284 wxString *arg1 = 0 ;
16285 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16286 bool result;
16287 bool temp1 = false ;
16288 unsigned int val2 ;
16289 int ecode2 = 0 ;
16290 PyObject * obj0 = 0 ;
16291 PyObject * obj1 = 0 ;
16292 char * kwnames[] = {
16293 (char *) "filename",(char *) "flags", NULL
16294 };
16295
16296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16297 {
16298 arg1 = wxString_in_helper(obj0);
16299 if (arg1 == NULL) SWIG_fail;
16300 temp1 = true;
16301 }
16302 if (obj1) {
16303 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16304 if (!SWIG_IsOK(ecode2)) {
16305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16306 }
16307 arg2 = static_cast< unsigned int >(val2);
16308 }
16309 {
16310 if (!wxPyCheckForApp()) SWIG_fail;
16311 PyThreadState* __tstate = wxPyBeginAllowThreads();
16312 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16313 wxPyEndAllowThreads(__tstate);
16314 if (PyErr_Occurred()) SWIG_fail;
16315 }
16316 {
16317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16318 }
16319 {
16320 if (temp1)
16321 delete arg1;
16322 }
16323 return resultobj;
16324 fail:
16325 {
16326 if (temp1)
16327 delete arg1;
16328 }
16329 return NULL;
16330 }
16331
16332
16333 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16334 PyObject *resultobj = 0;
16335
16336 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16337 {
16338 if (!wxPyCheckForApp()) SWIG_fail;
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 wxSound::Stop();
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 resultobj = SWIG_Py_Void();
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16352 PyObject *obj;
16353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16354 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16355 return SWIG_Py_Void();
16356 }
16357
16358 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16359 return SWIG_Python_InitShadowInstance(args);
16360 }
16361
16362 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16363 PyObject *resultobj = 0;
16364 wxString *arg1 = 0 ;
16365 wxString *arg2 = 0 ;
16366 wxString *arg3 = 0 ;
16367 wxString *arg4 = 0 ;
16368 wxFileTypeInfo *result = 0 ;
16369 bool temp1 = false ;
16370 bool temp2 = false ;
16371 bool temp3 = false ;
16372 bool temp4 = false ;
16373 PyObject * obj0 = 0 ;
16374 PyObject * obj1 = 0 ;
16375 PyObject * obj2 = 0 ;
16376 PyObject * obj3 = 0 ;
16377 char * kwnames[] = {
16378 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16379 };
16380
16381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16382 {
16383 arg1 = wxString_in_helper(obj0);
16384 if (arg1 == NULL) SWIG_fail;
16385 temp1 = true;
16386 }
16387 {
16388 arg2 = wxString_in_helper(obj1);
16389 if (arg2 == NULL) SWIG_fail;
16390 temp2 = true;
16391 }
16392 {
16393 arg3 = wxString_in_helper(obj2);
16394 if (arg3 == NULL) SWIG_fail;
16395 temp3 = true;
16396 }
16397 {
16398 arg4 = wxString_in_helper(obj3);
16399 if (arg4 == NULL) SWIG_fail;
16400 temp4 = true;
16401 }
16402 {
16403 PyThreadState* __tstate = wxPyBeginAllowThreads();
16404 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16405 wxPyEndAllowThreads(__tstate);
16406 if (PyErr_Occurred()) SWIG_fail;
16407 }
16408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16409 {
16410 if (temp1)
16411 delete arg1;
16412 }
16413 {
16414 if (temp2)
16415 delete arg2;
16416 }
16417 {
16418 if (temp3)
16419 delete arg3;
16420 }
16421 {
16422 if (temp4)
16423 delete arg4;
16424 }
16425 return resultobj;
16426 fail:
16427 {
16428 if (temp1)
16429 delete arg1;
16430 }
16431 {
16432 if (temp2)
16433 delete arg2;
16434 }
16435 {
16436 if (temp3)
16437 delete arg3;
16438 }
16439 {
16440 if (temp4)
16441 delete arg4;
16442 }
16443 return NULL;
16444 }
16445
16446
16447 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16448 PyObject *resultobj = 0;
16449 wxArrayString *arg1 = 0 ;
16450 wxFileTypeInfo *result = 0 ;
16451 bool temp1 = false ;
16452 PyObject * obj0 = 0 ;
16453 char * kwnames[] = {
16454 (char *) "sArray", NULL
16455 };
16456
16457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16458 {
16459 if (! PySequence_Check(obj0)) {
16460 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16461 SWIG_fail;
16462 }
16463 arg1 = new wxArrayString;
16464 temp1 = true;
16465 int i, len=PySequence_Length(obj0);
16466 for (i=0; i<len; i++) {
16467 PyObject* item = PySequence_GetItem(obj0, i);
16468 wxString* s = wxString_in_helper(item);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 arg1->Add(*s);
16471 delete s;
16472 Py_DECREF(item);
16473 }
16474 }
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16482 {
16483 if (temp1) delete arg1;
16484 }
16485 return resultobj;
16486 fail:
16487 {
16488 if (temp1) delete arg1;
16489 }
16490 return NULL;
16491 }
16492
16493
16494 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16495 PyObject *resultobj = 0;
16496 wxFileTypeInfo *result = 0 ;
16497
16498 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16499 {
16500 PyThreadState* __tstate = wxPyBeginAllowThreads();
16501 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16506 return resultobj;
16507 fail:
16508 return NULL;
16509 }
16510
16511
16512 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16513 PyObject *resultobj = 0;
16514 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16515 bool result;
16516 void *argp1 = 0 ;
16517 int res1 = 0 ;
16518 PyObject *swig_obj[1] ;
16519
16520 if (!args) SWIG_fail;
16521 swig_obj[0] = args;
16522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16523 if (!SWIG_IsOK(res1)) {
16524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16525 }
16526 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16530 wxPyEndAllowThreads(__tstate);
16531 if (PyErr_Occurred()) SWIG_fail;
16532 }
16533 {
16534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16535 }
16536 return resultobj;
16537 fail:
16538 return NULL;
16539 }
16540
16541
16542 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16543 PyObject *resultobj = 0;
16544 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16545 wxString *arg2 = 0 ;
16546 int arg3 = (int) 0 ;
16547 void *argp1 = 0 ;
16548 int res1 = 0 ;
16549 bool temp2 = false ;
16550 int val3 ;
16551 int ecode3 = 0 ;
16552 PyObject * obj0 = 0 ;
16553 PyObject * obj1 = 0 ;
16554 PyObject * obj2 = 0 ;
16555 char * kwnames[] = {
16556 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16557 };
16558
16559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16561 if (!SWIG_IsOK(res1)) {
16562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16563 }
16564 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16565 {
16566 arg2 = wxString_in_helper(obj1);
16567 if (arg2 == NULL) SWIG_fail;
16568 temp2 = true;
16569 }
16570 if (obj2) {
16571 ecode3 = SWIG_AsVal_int(obj2, &val3);
16572 if (!SWIG_IsOK(ecode3)) {
16573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16574 }
16575 arg3 = static_cast< int >(val3);
16576 }
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16580 wxPyEndAllowThreads(__tstate);
16581 if (PyErr_Occurred()) SWIG_fail;
16582 }
16583 resultobj = SWIG_Py_Void();
16584 {
16585 if (temp2)
16586 delete arg2;
16587 }
16588 return resultobj;
16589 fail:
16590 {
16591 if (temp2)
16592 delete arg2;
16593 }
16594 return NULL;
16595 }
16596
16597
16598 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj = 0;
16600 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16601 wxString *arg2 = 0 ;
16602 void *argp1 = 0 ;
16603 int res1 = 0 ;
16604 bool temp2 = false ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 char * kwnames[] = {
16608 (char *) "self",(char *) "shortDesc", NULL
16609 };
16610
16611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16613 if (!SWIG_IsOK(res1)) {
16614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16615 }
16616 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16617 {
16618 arg2 = wxString_in_helper(obj1);
16619 if (arg2 == NULL) SWIG_fail;
16620 temp2 = true;
16621 }
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 (arg1)->SetShortDesc((wxString const &)*arg2);
16625 wxPyEndAllowThreads(__tstate);
16626 if (PyErr_Occurred()) SWIG_fail;
16627 }
16628 resultobj = SWIG_Py_Void();
16629 {
16630 if (temp2)
16631 delete arg2;
16632 }
16633 return resultobj;
16634 fail:
16635 {
16636 if (temp2)
16637 delete arg2;
16638 }
16639 return NULL;
16640 }
16641
16642
16643 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16644 PyObject *resultobj = 0;
16645 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16646 wxString *result = 0 ;
16647 void *argp1 = 0 ;
16648 int res1 = 0 ;
16649 PyObject *swig_obj[1] ;
16650
16651 if (!args) SWIG_fail;
16652 swig_obj[0] = args;
16653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16654 if (!SWIG_IsOK(res1)) {
16655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16656 }
16657 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16658 {
16659 PyThreadState* __tstate = wxPyBeginAllowThreads();
16660 {
16661 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16662 result = (wxString *) &_result_ref;
16663 }
16664 wxPyEndAllowThreads(__tstate);
16665 if (PyErr_Occurred()) SWIG_fail;
16666 }
16667 {
16668 #if wxUSE_UNICODE
16669 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16670 #else
16671 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16672 #endif
16673 }
16674 return resultobj;
16675 fail:
16676 return NULL;
16677 }
16678
16679
16680 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16681 PyObject *resultobj = 0;
16682 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16683 wxString *result = 0 ;
16684 void *argp1 = 0 ;
16685 int res1 = 0 ;
16686 PyObject *swig_obj[1] ;
16687
16688 if (!args) SWIG_fail;
16689 swig_obj[0] = args;
16690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16691 if (!SWIG_IsOK(res1)) {
16692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16693 }
16694 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 {
16698 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16699 result = (wxString *) &_result_ref;
16700 }
16701 wxPyEndAllowThreads(__tstate);
16702 if (PyErr_Occurred()) SWIG_fail;
16703 }
16704 {
16705 #if wxUSE_UNICODE
16706 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16707 #else
16708 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16709 #endif
16710 }
16711 return resultobj;
16712 fail:
16713 return NULL;
16714 }
16715
16716
16717 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16718 PyObject *resultobj = 0;
16719 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16720 wxString *result = 0 ;
16721 void *argp1 = 0 ;
16722 int res1 = 0 ;
16723 PyObject *swig_obj[1] ;
16724
16725 if (!args) SWIG_fail;
16726 swig_obj[0] = args;
16727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16728 if (!SWIG_IsOK(res1)) {
16729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16730 }
16731 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16732 {
16733 PyThreadState* __tstate = wxPyBeginAllowThreads();
16734 {
16735 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16736 result = (wxString *) &_result_ref;
16737 }
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 {
16742 #if wxUSE_UNICODE
16743 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16744 #else
16745 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16746 #endif
16747 }
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16755 PyObject *resultobj = 0;
16756 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16757 wxString *result = 0 ;
16758 void *argp1 = 0 ;
16759 int res1 = 0 ;
16760 PyObject *swig_obj[1] ;
16761
16762 if (!args) SWIG_fail;
16763 swig_obj[0] = args;
16764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16765 if (!SWIG_IsOK(res1)) {
16766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16767 }
16768 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16769 {
16770 PyThreadState* __tstate = wxPyBeginAllowThreads();
16771 {
16772 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16773 result = (wxString *) &_result_ref;
16774 }
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 {
16779 #if wxUSE_UNICODE
16780 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16781 #else
16782 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16783 #endif
16784 }
16785 return resultobj;
16786 fail:
16787 return NULL;
16788 }
16789
16790
16791 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16792 PyObject *resultobj = 0;
16793 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16794 wxString *result = 0 ;
16795 void *argp1 = 0 ;
16796 int res1 = 0 ;
16797 PyObject *swig_obj[1] ;
16798
16799 if (!args) SWIG_fail;
16800 swig_obj[0] = args;
16801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16802 if (!SWIG_IsOK(res1)) {
16803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16804 }
16805 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 {
16809 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16810 result = (wxString *) &_result_ref;
16811 }
16812 wxPyEndAllowThreads(__tstate);
16813 if (PyErr_Occurred()) SWIG_fail;
16814 }
16815 {
16816 #if wxUSE_UNICODE
16817 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16818 #else
16819 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16820 #endif
16821 }
16822 return resultobj;
16823 fail:
16824 return NULL;
16825 }
16826
16827
16828 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16829 PyObject *resultobj = 0;
16830 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16831 wxArrayString *result = 0 ;
16832 void *argp1 = 0 ;
16833 int res1 = 0 ;
16834 PyObject *swig_obj[1] ;
16835
16836 if (!args) SWIG_fail;
16837 swig_obj[0] = args;
16838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16839 if (!SWIG_IsOK(res1)) {
16840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16841 }
16842 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16843 {
16844 PyThreadState* __tstate = wxPyBeginAllowThreads();
16845 {
16846 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16847 result = (wxArrayString *) &_result_ref;
16848 }
16849 wxPyEndAllowThreads(__tstate);
16850 if (PyErr_Occurred()) SWIG_fail;
16851 }
16852 {
16853 resultobj = wxArrayString2PyList_helper(*result);
16854 }
16855 return resultobj;
16856 fail:
16857 return NULL;
16858 }
16859
16860
16861 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16862 PyObject *resultobj = 0;
16863 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16864 size_t result;
16865 void *argp1 = 0 ;
16866 int res1 = 0 ;
16867 PyObject *swig_obj[1] ;
16868
16869 if (!args) SWIG_fail;
16870 swig_obj[0] = args;
16871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16874 }
16875 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16876 {
16877 PyThreadState* __tstate = wxPyBeginAllowThreads();
16878 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16879 wxPyEndAllowThreads(__tstate);
16880 if (PyErr_Occurred()) SWIG_fail;
16881 }
16882 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16883 return resultobj;
16884 fail:
16885 return NULL;
16886 }
16887
16888
16889 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16890 PyObject *resultobj = 0;
16891 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16892 wxString *result = 0 ;
16893 void *argp1 = 0 ;
16894 int res1 = 0 ;
16895 PyObject *swig_obj[1] ;
16896
16897 if (!args) SWIG_fail;
16898 swig_obj[0] = args;
16899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16900 if (!SWIG_IsOK(res1)) {
16901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16902 }
16903 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 {
16907 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16908 result = (wxString *) &_result_ref;
16909 }
16910 wxPyEndAllowThreads(__tstate);
16911 if (PyErr_Occurred()) SWIG_fail;
16912 }
16913 {
16914 #if wxUSE_UNICODE
16915 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16916 #else
16917 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16918 #endif
16919 }
16920 return resultobj;
16921 fail:
16922 return NULL;
16923 }
16924
16925
16926 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16927 PyObject *resultobj = 0;
16928 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16929 int result;
16930 void *argp1 = 0 ;
16931 int res1 = 0 ;
16932 PyObject *swig_obj[1] ;
16933
16934 if (!args) SWIG_fail;
16935 swig_obj[0] = args;
16936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16937 if (!SWIG_IsOK(res1)) {
16938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16939 }
16940 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16941 {
16942 PyThreadState* __tstate = wxPyBeginAllowThreads();
16943 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16944 wxPyEndAllowThreads(__tstate);
16945 if (PyErr_Occurred()) SWIG_fail;
16946 }
16947 resultobj = SWIG_From_int(static_cast< int >(result));
16948 return resultobj;
16949 fail:
16950 return NULL;
16951 }
16952
16953
16954 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16955 PyObject *obj;
16956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16957 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16958 return SWIG_Py_Void();
16959 }
16960
16961 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16962 return SWIG_Python_InitShadowInstance(args);
16963 }
16964
16965 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj = 0;
16967 wxFileTypeInfo *arg1 = 0 ;
16968 wxFileType *result = 0 ;
16969 void *argp1 = 0 ;
16970 int res1 = 0 ;
16971 PyObject * obj0 = 0 ;
16972 char * kwnames[] = {
16973 (char *) "ftInfo", NULL
16974 };
16975
16976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16977 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16978 if (!SWIG_IsOK(res1)) {
16979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16980 }
16981 if (!argp1) {
16982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16983 }
16984 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16999 PyObject *resultobj = 0;
17000 wxFileType *arg1 = (wxFileType *) 0 ;
17001 void *argp1 = 0 ;
17002 int res1 = 0 ;
17003 PyObject *swig_obj[1] ;
17004
17005 if (!args) SWIG_fail;
17006 swig_obj[0] = args;
17007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
17008 if (!SWIG_IsOK(res1)) {
17009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
17010 }
17011 arg1 = reinterpret_cast< wxFileType * >(argp1);
17012 {
17013 PyThreadState* __tstate = wxPyBeginAllowThreads();
17014 delete arg1;
17015
17016 wxPyEndAllowThreads(__tstate);
17017 if (PyErr_Occurred()) SWIG_fail;
17018 }
17019 resultobj = SWIG_Py_Void();
17020 return resultobj;
17021 fail:
17022 return NULL;
17023 }
17024
17025
17026 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17027 PyObject *resultobj = 0;
17028 wxFileType *arg1 = (wxFileType *) 0 ;
17029 PyObject *result = 0 ;
17030 void *argp1 = 0 ;
17031 int res1 = 0 ;
17032 PyObject *swig_obj[1] ;
17033
17034 if (!args) SWIG_fail;
17035 swig_obj[0] = args;
17036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17037 if (!SWIG_IsOK(res1)) {
17038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
17039 }
17040 arg1 = reinterpret_cast< wxFileType * >(argp1);
17041 {
17042 PyThreadState* __tstate = wxPyBeginAllowThreads();
17043 result = (PyObject *)wxFileType_GetMimeType(arg1);
17044 wxPyEndAllowThreads(__tstate);
17045 if (PyErr_Occurred()) SWIG_fail;
17046 }
17047 resultobj = result;
17048 return resultobj;
17049 fail:
17050 return NULL;
17051 }
17052
17053
17054 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17055 PyObject *resultobj = 0;
17056 wxFileType *arg1 = (wxFileType *) 0 ;
17057 PyObject *result = 0 ;
17058 void *argp1 = 0 ;
17059 int res1 = 0 ;
17060 PyObject *swig_obj[1] ;
17061
17062 if (!args) SWIG_fail;
17063 swig_obj[0] = args;
17064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17065 if (!SWIG_IsOK(res1)) {
17066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
17067 }
17068 arg1 = reinterpret_cast< wxFileType * >(argp1);
17069 {
17070 PyThreadState* __tstate = wxPyBeginAllowThreads();
17071 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
17072 wxPyEndAllowThreads(__tstate);
17073 if (PyErr_Occurred()) SWIG_fail;
17074 }
17075 resultobj = result;
17076 return resultobj;
17077 fail:
17078 return NULL;
17079 }
17080
17081
17082 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17083 PyObject *resultobj = 0;
17084 wxFileType *arg1 = (wxFileType *) 0 ;
17085 PyObject *result = 0 ;
17086 void *argp1 = 0 ;
17087 int res1 = 0 ;
17088 PyObject *swig_obj[1] ;
17089
17090 if (!args) SWIG_fail;
17091 swig_obj[0] = args;
17092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17093 if (!SWIG_IsOK(res1)) {
17094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
17095 }
17096 arg1 = reinterpret_cast< wxFileType * >(argp1);
17097 {
17098 PyThreadState* __tstate = wxPyBeginAllowThreads();
17099 result = (PyObject *)wxFileType_GetExtensions(arg1);
17100 wxPyEndAllowThreads(__tstate);
17101 if (PyErr_Occurred()) SWIG_fail;
17102 }
17103 resultobj = result;
17104 return resultobj;
17105 fail:
17106 return NULL;
17107 }
17108
17109
17110 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17111 PyObject *resultobj = 0;
17112 wxFileType *arg1 = (wxFileType *) 0 ;
17113 wxIcon *result = 0 ;
17114 void *argp1 = 0 ;
17115 int res1 = 0 ;
17116 PyObject *swig_obj[1] ;
17117
17118 if (!args) SWIG_fail;
17119 swig_obj[0] = args;
17120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17121 if (!SWIG_IsOK(res1)) {
17122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17123 }
17124 arg1 = reinterpret_cast< wxFileType * >(argp1);
17125 {
17126 PyThreadState* __tstate = wxPyBeginAllowThreads();
17127 result = (wxIcon *)wxFileType_GetIcon(arg1);
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
17132 return resultobj;
17133 fail:
17134 return NULL;
17135 }
17136
17137
17138 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17139 PyObject *resultobj = 0;
17140 wxFileType *arg1 = (wxFileType *) 0 ;
17141 PyObject *result = 0 ;
17142 void *argp1 = 0 ;
17143 int res1 = 0 ;
17144 PyObject *swig_obj[1] ;
17145
17146 if (!args) SWIG_fail;
17147 swig_obj[0] = args;
17148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17149 if (!SWIG_IsOK(res1)) {
17150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
17151 }
17152 arg1 = reinterpret_cast< wxFileType * >(argp1);
17153 {
17154 PyThreadState* __tstate = wxPyBeginAllowThreads();
17155 result = (PyObject *)wxFileType_GetIconInfo(arg1);
17156 wxPyEndAllowThreads(__tstate);
17157 if (PyErr_Occurred()) SWIG_fail;
17158 }
17159 resultobj = result;
17160 return resultobj;
17161 fail:
17162 return NULL;
17163 }
17164
17165
17166 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17167 PyObject *resultobj = 0;
17168 wxFileType *arg1 = (wxFileType *) 0 ;
17169 PyObject *result = 0 ;
17170 void *argp1 = 0 ;
17171 int res1 = 0 ;
17172 PyObject *swig_obj[1] ;
17173
17174 if (!args) SWIG_fail;
17175 swig_obj[0] = args;
17176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17177 if (!SWIG_IsOK(res1)) {
17178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
17179 }
17180 arg1 = reinterpret_cast< wxFileType * >(argp1);
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = (PyObject *)wxFileType_GetDescription(arg1);
17184 wxPyEndAllowThreads(__tstate);
17185 if (PyErr_Occurred()) SWIG_fail;
17186 }
17187 resultobj = result;
17188 return resultobj;
17189 fail:
17190 return NULL;
17191 }
17192
17193
17194 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj = 0;
17196 wxFileType *arg1 = (wxFileType *) 0 ;
17197 wxString *arg2 = 0 ;
17198 wxString const &arg3_defvalue = wxPyEmptyString ;
17199 wxString *arg3 = (wxString *) &arg3_defvalue ;
17200 PyObject *result = 0 ;
17201 void *argp1 = 0 ;
17202 int res1 = 0 ;
17203 bool temp2 = false ;
17204 bool temp3 = false ;
17205 PyObject * obj0 = 0 ;
17206 PyObject * obj1 = 0 ;
17207 PyObject * obj2 = 0 ;
17208 char * kwnames[] = {
17209 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17210 };
17211
17212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17214 if (!SWIG_IsOK(res1)) {
17215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17216 }
17217 arg1 = reinterpret_cast< wxFileType * >(argp1);
17218 {
17219 arg2 = wxString_in_helper(obj1);
17220 if (arg2 == NULL) SWIG_fail;
17221 temp2 = true;
17222 }
17223 if (obj2) {
17224 {
17225 arg3 = wxString_in_helper(obj2);
17226 if (arg3 == NULL) SWIG_fail;
17227 temp3 = true;
17228 }
17229 }
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17233 wxPyEndAllowThreads(__tstate);
17234 if (PyErr_Occurred()) SWIG_fail;
17235 }
17236 resultobj = result;
17237 {
17238 if (temp2)
17239 delete arg2;
17240 }
17241 {
17242 if (temp3)
17243 delete arg3;
17244 }
17245 return resultobj;
17246 fail:
17247 {
17248 if (temp2)
17249 delete arg2;
17250 }
17251 {
17252 if (temp3)
17253 delete arg3;
17254 }
17255 return NULL;
17256 }
17257
17258
17259 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj = 0;
17261 wxFileType *arg1 = (wxFileType *) 0 ;
17262 wxString *arg2 = 0 ;
17263 wxString const &arg3_defvalue = wxPyEmptyString ;
17264 wxString *arg3 = (wxString *) &arg3_defvalue ;
17265 PyObject *result = 0 ;
17266 void *argp1 = 0 ;
17267 int res1 = 0 ;
17268 bool temp2 = false ;
17269 bool temp3 = false ;
17270 PyObject * obj0 = 0 ;
17271 PyObject * obj1 = 0 ;
17272 PyObject * obj2 = 0 ;
17273 char * kwnames[] = {
17274 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17275 };
17276
17277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17279 if (!SWIG_IsOK(res1)) {
17280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17281 }
17282 arg1 = reinterpret_cast< wxFileType * >(argp1);
17283 {
17284 arg2 = wxString_in_helper(obj1);
17285 if (arg2 == NULL) SWIG_fail;
17286 temp2 = true;
17287 }
17288 if (obj2) {
17289 {
17290 arg3 = wxString_in_helper(obj2);
17291 if (arg3 == NULL) SWIG_fail;
17292 temp3 = true;
17293 }
17294 }
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 resultobj = result;
17302 {
17303 if (temp2)
17304 delete arg2;
17305 }
17306 {
17307 if (temp3)
17308 delete arg3;
17309 }
17310 return resultobj;
17311 fail:
17312 {
17313 if (temp2)
17314 delete arg2;
17315 }
17316 {
17317 if (temp3)
17318 delete arg3;
17319 }
17320 return NULL;
17321 }
17322
17323
17324 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17325 PyObject *resultobj = 0;
17326 wxFileType *arg1 = (wxFileType *) 0 ;
17327 wxString *arg2 = 0 ;
17328 wxString const &arg3_defvalue = wxPyEmptyString ;
17329 wxString *arg3 = (wxString *) &arg3_defvalue ;
17330 PyObject *result = 0 ;
17331 void *argp1 = 0 ;
17332 int res1 = 0 ;
17333 bool temp2 = false ;
17334 bool temp3 = false ;
17335 PyObject * obj0 = 0 ;
17336 PyObject * obj1 = 0 ;
17337 PyObject * obj2 = 0 ;
17338 char * kwnames[] = {
17339 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17340 };
17341
17342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17344 if (!SWIG_IsOK(res1)) {
17345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17346 }
17347 arg1 = reinterpret_cast< wxFileType * >(argp1);
17348 {
17349 arg2 = wxString_in_helper(obj1);
17350 if (arg2 == NULL) SWIG_fail;
17351 temp2 = true;
17352 }
17353 if (obj2) {
17354 {
17355 arg3 = wxString_in_helper(obj2);
17356 if (arg3 == NULL) SWIG_fail;
17357 temp3 = true;
17358 }
17359 }
17360 {
17361 PyThreadState* __tstate = wxPyBeginAllowThreads();
17362 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17363 wxPyEndAllowThreads(__tstate);
17364 if (PyErr_Occurred()) SWIG_fail;
17365 }
17366 resultobj = result;
17367 {
17368 if (temp2)
17369 delete arg2;
17370 }
17371 {
17372 if (temp3)
17373 delete arg3;
17374 }
17375 return resultobj;
17376 fail:
17377 {
17378 if (temp2)
17379 delete arg2;
17380 }
17381 {
17382 if (temp3)
17383 delete arg3;
17384 }
17385 return NULL;
17386 }
17387
17388
17389 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17390 PyObject *resultobj = 0;
17391 wxFileType *arg1 = (wxFileType *) 0 ;
17392 wxString *arg2 = 0 ;
17393 wxString *arg3 = 0 ;
17394 bool arg4 = (bool) true ;
17395 bool result;
17396 void *argp1 = 0 ;
17397 int res1 = 0 ;
17398 bool temp2 = false ;
17399 bool temp3 = false ;
17400 bool val4 ;
17401 int ecode4 = 0 ;
17402 PyObject * obj0 = 0 ;
17403 PyObject * obj1 = 0 ;
17404 PyObject * obj2 = 0 ;
17405 PyObject * obj3 = 0 ;
17406 char * kwnames[] = {
17407 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17408 };
17409
17410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17412 if (!SWIG_IsOK(res1)) {
17413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17414 }
17415 arg1 = reinterpret_cast< wxFileType * >(argp1);
17416 {
17417 arg2 = wxString_in_helper(obj1);
17418 if (arg2 == NULL) SWIG_fail;
17419 temp2 = true;
17420 }
17421 {
17422 arg3 = wxString_in_helper(obj2);
17423 if (arg3 == NULL) SWIG_fail;
17424 temp3 = true;
17425 }
17426 if (obj3) {
17427 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17428 if (!SWIG_IsOK(ecode4)) {
17429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17430 }
17431 arg4 = static_cast< bool >(val4);
17432 }
17433 {
17434 PyThreadState* __tstate = wxPyBeginAllowThreads();
17435 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17436 wxPyEndAllowThreads(__tstate);
17437 if (PyErr_Occurred()) SWIG_fail;
17438 }
17439 {
17440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17441 }
17442 {
17443 if (temp2)
17444 delete arg2;
17445 }
17446 {
17447 if (temp3)
17448 delete arg3;
17449 }
17450 return resultobj;
17451 fail:
17452 {
17453 if (temp2)
17454 delete arg2;
17455 }
17456 {
17457 if (temp3)
17458 delete arg3;
17459 }
17460 return NULL;
17461 }
17462
17463
17464 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17465 PyObject *resultobj = 0;
17466 wxFileType *arg1 = (wxFileType *) 0 ;
17467 wxString const &arg2_defvalue = wxPyEmptyString ;
17468 wxString *arg2 = (wxString *) &arg2_defvalue ;
17469 int arg3 = (int) 0 ;
17470 bool result;
17471 void *argp1 = 0 ;
17472 int res1 = 0 ;
17473 bool temp2 = false ;
17474 int val3 ;
17475 int ecode3 = 0 ;
17476 PyObject * obj0 = 0 ;
17477 PyObject * obj1 = 0 ;
17478 PyObject * obj2 = 0 ;
17479 char * kwnames[] = {
17480 (char *) "self",(char *) "cmd",(char *) "index", NULL
17481 };
17482
17483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17485 if (!SWIG_IsOK(res1)) {
17486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17487 }
17488 arg1 = reinterpret_cast< wxFileType * >(argp1);
17489 if (obj1) {
17490 {
17491 arg2 = wxString_in_helper(obj1);
17492 if (arg2 == NULL) SWIG_fail;
17493 temp2 = true;
17494 }
17495 }
17496 if (obj2) {
17497 ecode3 = SWIG_AsVal_int(obj2, &val3);
17498 if (!SWIG_IsOK(ecode3)) {
17499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17500 }
17501 arg3 = static_cast< int >(val3);
17502 }
17503 {
17504 PyThreadState* __tstate = wxPyBeginAllowThreads();
17505 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17506 wxPyEndAllowThreads(__tstate);
17507 if (PyErr_Occurred()) SWIG_fail;
17508 }
17509 {
17510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17511 }
17512 {
17513 if (temp2)
17514 delete arg2;
17515 }
17516 return resultobj;
17517 fail:
17518 {
17519 if (temp2)
17520 delete arg2;
17521 }
17522 return NULL;
17523 }
17524
17525
17526 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17527 PyObject *resultobj = 0;
17528 wxFileType *arg1 = (wxFileType *) 0 ;
17529 bool result;
17530 void *argp1 = 0 ;
17531 int res1 = 0 ;
17532 PyObject *swig_obj[1] ;
17533
17534 if (!args) SWIG_fail;
17535 swig_obj[0] = args;
17536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17537 if (!SWIG_IsOK(res1)) {
17538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17539 }
17540 arg1 = reinterpret_cast< wxFileType * >(argp1);
17541 {
17542 PyThreadState* __tstate = wxPyBeginAllowThreads();
17543 result = (bool)(arg1)->Unassociate();
17544 wxPyEndAllowThreads(__tstate);
17545 if (PyErr_Occurred()) SWIG_fail;
17546 }
17547 {
17548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17549 }
17550 return resultobj;
17551 fail:
17552 return NULL;
17553 }
17554
17555
17556 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj = 0;
17558 wxString *arg1 = 0 ;
17559 wxString *arg2 = 0 ;
17560 wxString const &arg3_defvalue = wxPyEmptyString ;
17561 wxString *arg3 = (wxString *) &arg3_defvalue ;
17562 wxString result;
17563 bool temp1 = false ;
17564 bool temp2 = false ;
17565 bool temp3 = false ;
17566 PyObject * obj0 = 0 ;
17567 PyObject * obj1 = 0 ;
17568 PyObject * obj2 = 0 ;
17569 char * kwnames[] = {
17570 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17571 };
17572
17573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17574 {
17575 arg1 = wxString_in_helper(obj0);
17576 if (arg1 == NULL) SWIG_fail;
17577 temp1 = true;
17578 }
17579 {
17580 arg2 = wxString_in_helper(obj1);
17581 if (arg2 == NULL) SWIG_fail;
17582 temp2 = true;
17583 }
17584 if (obj2) {
17585 {
17586 arg3 = wxString_in_helper(obj2);
17587 if (arg3 == NULL) SWIG_fail;
17588 temp3 = true;
17589 }
17590 }
17591 {
17592 PyThreadState* __tstate = wxPyBeginAllowThreads();
17593 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17594 wxPyEndAllowThreads(__tstate);
17595 if (PyErr_Occurred()) SWIG_fail;
17596 }
17597 {
17598 #if wxUSE_UNICODE
17599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17600 #else
17601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17602 #endif
17603 }
17604 {
17605 if (temp1)
17606 delete arg1;
17607 }
17608 {
17609 if (temp2)
17610 delete arg2;
17611 }
17612 {
17613 if (temp3)
17614 delete arg3;
17615 }
17616 return resultobj;
17617 fail:
17618 {
17619 if (temp1)
17620 delete arg1;
17621 }
17622 {
17623 if (temp2)
17624 delete arg2;
17625 }
17626 {
17627 if (temp3)
17628 delete arg3;
17629 }
17630 return NULL;
17631 }
17632
17633
17634 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17635 PyObject *obj;
17636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17637 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17638 return SWIG_Py_Void();
17639 }
17640
17641 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17642 return SWIG_Python_InitShadowInstance(args);
17643 }
17644
17645 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17646 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17647 return 1;
17648 }
17649
17650
17651 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17652 PyObject *pyobj = 0;
17653
17654 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17655 return pyobj;
17656 }
17657
17658
17659 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17660 PyObject *resultobj = 0;
17661 wxString *arg1 = 0 ;
17662 wxString *arg2 = 0 ;
17663 bool result;
17664 bool temp1 = false ;
17665 bool temp2 = false ;
17666 PyObject * obj0 = 0 ;
17667 PyObject * obj1 = 0 ;
17668 char * kwnames[] = {
17669 (char *) "mimeType",(char *) "wildcard", NULL
17670 };
17671
17672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17673 {
17674 arg1 = wxString_in_helper(obj0);
17675 if (arg1 == NULL) SWIG_fail;
17676 temp1 = true;
17677 }
17678 {
17679 arg2 = wxString_in_helper(obj1);
17680 if (arg2 == NULL) SWIG_fail;
17681 temp2 = true;
17682 }
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 {
17690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17691 }
17692 {
17693 if (temp1)
17694 delete arg1;
17695 }
17696 {
17697 if (temp2)
17698 delete arg2;
17699 }
17700 return resultobj;
17701 fail:
17702 {
17703 if (temp1)
17704 delete arg1;
17705 }
17706 {
17707 if (temp2)
17708 delete arg2;
17709 }
17710 return NULL;
17711 }
17712
17713
17714 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17715 PyObject *resultobj = 0;
17716 wxMimeTypesManager *result = 0 ;
17717
17718 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17719 {
17720 PyThreadState* __tstate = wxPyBeginAllowThreads();
17721 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17722 wxPyEndAllowThreads(__tstate);
17723 if (PyErr_Occurred()) SWIG_fail;
17724 }
17725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17726 return resultobj;
17727 fail:
17728 return NULL;
17729 }
17730
17731
17732 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17733 PyObject *resultobj = 0;
17734 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17735 int arg2 = (int) wxMAILCAP_ALL ;
17736 wxString const &arg3_defvalue = wxPyEmptyString ;
17737 wxString *arg3 = (wxString *) &arg3_defvalue ;
17738 void *argp1 = 0 ;
17739 int res1 = 0 ;
17740 int val2 ;
17741 int ecode2 = 0 ;
17742 bool temp3 = false ;
17743 PyObject * obj0 = 0 ;
17744 PyObject * obj1 = 0 ;
17745 PyObject * obj2 = 0 ;
17746 char * kwnames[] = {
17747 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17748 };
17749
17750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17752 if (!SWIG_IsOK(res1)) {
17753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17754 }
17755 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17756 if (obj1) {
17757 ecode2 = SWIG_AsVal_int(obj1, &val2);
17758 if (!SWIG_IsOK(ecode2)) {
17759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17760 }
17761 arg2 = static_cast< int >(val2);
17762 }
17763 if (obj2) {
17764 {
17765 arg3 = wxString_in_helper(obj2);
17766 if (arg3 == NULL) SWIG_fail;
17767 temp3 = true;
17768 }
17769 }
17770 {
17771 PyThreadState* __tstate = wxPyBeginAllowThreads();
17772 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17773 wxPyEndAllowThreads(__tstate);
17774 if (PyErr_Occurred()) SWIG_fail;
17775 }
17776 resultobj = SWIG_Py_Void();
17777 {
17778 if (temp3)
17779 delete arg3;
17780 }
17781 return resultobj;
17782 fail:
17783 {
17784 if (temp3)
17785 delete arg3;
17786 }
17787 return NULL;
17788 }
17789
17790
17791 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17792 PyObject *resultobj = 0;
17793 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17794 void *argp1 = 0 ;
17795 int res1 = 0 ;
17796 PyObject *swig_obj[1] ;
17797
17798 if (!args) SWIG_fail;
17799 swig_obj[0] = args;
17800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17801 if (!SWIG_IsOK(res1)) {
17802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17803 }
17804 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17805 {
17806 PyThreadState* __tstate = wxPyBeginAllowThreads();
17807 (arg1)->ClearData();
17808 wxPyEndAllowThreads(__tstate);
17809 if (PyErr_Occurred()) SWIG_fail;
17810 }
17811 resultobj = SWIG_Py_Void();
17812 return resultobj;
17813 fail:
17814 return NULL;
17815 }
17816
17817
17818 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17819 PyObject *resultobj = 0;
17820 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17821 wxString *arg2 = 0 ;
17822 wxFileType *result = 0 ;
17823 void *argp1 = 0 ;
17824 int res1 = 0 ;
17825 bool temp2 = false ;
17826 PyObject * obj0 = 0 ;
17827 PyObject * obj1 = 0 ;
17828 char * kwnames[] = {
17829 (char *) "self",(char *) "ext", NULL
17830 };
17831
17832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17834 if (!SWIG_IsOK(res1)) {
17835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17836 }
17837 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17838 {
17839 arg2 = wxString_in_helper(obj1);
17840 if (arg2 == NULL) SWIG_fail;
17841 temp2 = true;
17842 }
17843 {
17844 PyThreadState* __tstate = wxPyBeginAllowThreads();
17845 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17846 wxPyEndAllowThreads(__tstate);
17847 if (PyErr_Occurred()) SWIG_fail;
17848 }
17849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17850 {
17851 if (temp2)
17852 delete arg2;
17853 }
17854 return resultobj;
17855 fail:
17856 {
17857 if (temp2)
17858 delete arg2;
17859 }
17860 return NULL;
17861 }
17862
17863
17864 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17865 PyObject *resultobj = 0;
17866 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17867 wxString *arg2 = 0 ;
17868 wxFileType *result = 0 ;
17869 void *argp1 = 0 ;
17870 int res1 = 0 ;
17871 bool temp2 = false ;
17872 PyObject * obj0 = 0 ;
17873 PyObject * obj1 = 0 ;
17874 char * kwnames[] = {
17875 (char *) "self",(char *) "mimeType", NULL
17876 };
17877
17878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17880 if (!SWIG_IsOK(res1)) {
17881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17882 }
17883 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17884 {
17885 arg2 = wxString_in_helper(obj1);
17886 if (arg2 == NULL) SWIG_fail;
17887 temp2 = true;
17888 }
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17896 {
17897 if (temp2)
17898 delete arg2;
17899 }
17900 return resultobj;
17901 fail:
17902 {
17903 if (temp2)
17904 delete arg2;
17905 }
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj = 0;
17912 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17913 wxString *arg2 = 0 ;
17914 bool arg3 = (bool) false ;
17915 bool result;
17916 void *argp1 = 0 ;
17917 int res1 = 0 ;
17918 bool temp2 = false ;
17919 bool val3 ;
17920 int ecode3 = 0 ;
17921 PyObject * obj0 = 0 ;
17922 PyObject * obj1 = 0 ;
17923 PyObject * obj2 = 0 ;
17924 char * kwnames[] = {
17925 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17926 };
17927
17928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17930 if (!SWIG_IsOK(res1)) {
17931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17932 }
17933 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17934 {
17935 arg2 = wxString_in_helper(obj1);
17936 if (arg2 == NULL) SWIG_fail;
17937 temp2 = true;
17938 }
17939 if (obj2) {
17940 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17941 if (!SWIG_IsOK(ecode3)) {
17942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17943 }
17944 arg3 = static_cast< bool >(val3);
17945 }
17946 {
17947 PyThreadState* __tstate = wxPyBeginAllowThreads();
17948 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 {
17953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17954 }
17955 {
17956 if (temp2)
17957 delete arg2;
17958 }
17959 return resultobj;
17960 fail:
17961 {
17962 if (temp2)
17963 delete arg2;
17964 }
17965 return NULL;
17966 }
17967
17968
17969 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj = 0;
17971 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17972 wxString *arg2 = 0 ;
17973 bool result;
17974 void *argp1 = 0 ;
17975 int res1 = 0 ;
17976 bool temp2 = false ;
17977 PyObject * obj0 = 0 ;
17978 PyObject * obj1 = 0 ;
17979 char * kwnames[] = {
17980 (char *) "self",(char *) "filename", NULL
17981 };
17982
17983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17985 if (!SWIG_IsOK(res1)) {
17986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17987 }
17988 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17989 {
17990 arg2 = wxString_in_helper(obj1);
17991 if (arg2 == NULL) SWIG_fail;
17992 temp2 = true;
17993 }
17994 {
17995 PyThreadState* __tstate = wxPyBeginAllowThreads();
17996 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17997 wxPyEndAllowThreads(__tstate);
17998 if (PyErr_Occurred()) SWIG_fail;
17999 }
18000 {
18001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18002 }
18003 {
18004 if (temp2)
18005 delete arg2;
18006 }
18007 return resultobj;
18008 fail:
18009 {
18010 if (temp2)
18011 delete arg2;
18012 }
18013 return NULL;
18014 }
18015
18016
18017 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18018 PyObject *resultobj = 0;
18019 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18020 PyObject *result = 0 ;
18021 void *argp1 = 0 ;
18022 int res1 = 0 ;
18023 PyObject *swig_obj[1] ;
18024
18025 if (!args) SWIG_fail;
18026 swig_obj[0] = args;
18027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18028 if (!SWIG_IsOK(res1)) {
18029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18030 }
18031 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18032 {
18033 PyThreadState* __tstate = wxPyBeginAllowThreads();
18034 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
18035 wxPyEndAllowThreads(__tstate);
18036 if (PyErr_Occurred()) SWIG_fail;
18037 }
18038 resultobj = result;
18039 return resultobj;
18040 fail:
18041 return NULL;
18042 }
18043
18044
18045 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18046 PyObject *resultobj = 0;
18047 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18048 wxFileTypeInfo *arg2 = 0 ;
18049 void *argp1 = 0 ;
18050 int res1 = 0 ;
18051 void *argp2 = 0 ;
18052 int res2 = 0 ;
18053 PyObject * obj0 = 0 ;
18054 PyObject * obj1 = 0 ;
18055 char * kwnames[] = {
18056 (char *) "self",(char *) "ft", NULL
18057 };
18058
18059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
18060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18061 if (!SWIG_IsOK(res1)) {
18062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18063 }
18064 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18065 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18066 if (!SWIG_IsOK(res2)) {
18067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18068 }
18069 if (!argp2) {
18070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18071 }
18072 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
18076 wxPyEndAllowThreads(__tstate);
18077 if (PyErr_Occurred()) SWIG_fail;
18078 }
18079 resultobj = SWIG_Py_Void();
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18087 PyObject *resultobj = 0;
18088 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18089 wxFileTypeInfo *arg2 = 0 ;
18090 wxFileType *result = 0 ;
18091 void *argp1 = 0 ;
18092 int res1 = 0 ;
18093 void *argp2 = 0 ;
18094 int res2 = 0 ;
18095 PyObject * obj0 = 0 ;
18096 PyObject * obj1 = 0 ;
18097 char * kwnames[] = {
18098 (char *) "self",(char *) "ftInfo", NULL
18099 };
18100
18101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
18102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18103 if (!SWIG_IsOK(res1)) {
18104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18105 }
18106 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18107 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
18108 if (!SWIG_IsOK(res2)) {
18109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18110 }
18111 if (!argp2) {
18112 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
18113 }
18114 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
18115 {
18116 PyThreadState* __tstate = wxPyBeginAllowThreads();
18117 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
18118 wxPyEndAllowThreads(__tstate);
18119 if (PyErr_Occurred()) SWIG_fail;
18120 }
18121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
18122 return resultobj;
18123 fail:
18124 return NULL;
18125 }
18126
18127
18128 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18129 PyObject *resultobj = 0;
18130 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18131 wxFileType *arg2 = (wxFileType *) 0 ;
18132 bool result;
18133 void *argp1 = 0 ;
18134 int res1 = 0 ;
18135 void *argp2 = 0 ;
18136 int res2 = 0 ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 char * kwnames[] = {
18140 (char *) "self",(char *) "ft", NULL
18141 };
18142
18143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
18144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18147 }
18148 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
18150 if (!SWIG_IsOK(res2)) {
18151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
18152 }
18153 arg2 = reinterpret_cast< wxFileType * >(argp2);
18154 {
18155 PyThreadState* __tstate = wxPyBeginAllowThreads();
18156 result = (bool)(arg1)->Unassociate(arg2);
18157 wxPyEndAllowThreads(__tstate);
18158 if (PyErr_Occurred()) SWIG_fail;
18159 }
18160 {
18161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18162 }
18163 return resultobj;
18164 fail:
18165 return NULL;
18166 }
18167
18168
18169 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18170 PyObject *resultobj = 0;
18171 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
18172 void *argp1 = 0 ;
18173 int res1 = 0 ;
18174 PyObject *swig_obj[1] ;
18175
18176 if (!args) SWIG_fail;
18177 swig_obj[0] = args;
18178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
18179 if (!SWIG_IsOK(res1)) {
18180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
18181 }
18182 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 delete arg1;
18186
18187 wxPyEndAllowThreads(__tstate);
18188 if (PyErr_Occurred()) SWIG_fail;
18189 }
18190 resultobj = SWIG_Py_Void();
18191 return resultobj;
18192 fail:
18193 return NULL;
18194 }
18195
18196
18197 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18198 PyObject *obj;
18199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18200 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
18201 return SWIG_Py_Void();
18202 }
18203
18204 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18205 return SWIG_Python_InitShadowInstance(args);
18206 }
18207
18208 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18209 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18210 return 1;
18211 }
18212
18213
18214 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18215 PyObject *pyobj = 0;
18216
18217 {
18218 #if wxUSE_UNICODE
18219 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18220 #else
18221 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18222 #endif
18223 }
18224 return pyobj;
18225 }
18226
18227
18228 SWIGINTERN int ART_MENU_set(PyObject *) {
18229 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18230 return 1;
18231 }
18232
18233
18234 SWIGINTERN PyObject *ART_MENU_get(void) {
18235 PyObject *pyobj = 0;
18236
18237 {
18238 #if wxUSE_UNICODE
18239 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18240 #else
18241 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18242 #endif
18243 }
18244 return pyobj;
18245 }
18246
18247
18248 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18249 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18250 return 1;
18251 }
18252
18253
18254 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18255 PyObject *pyobj = 0;
18256
18257 {
18258 #if wxUSE_UNICODE
18259 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18260 #else
18261 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18262 #endif
18263 }
18264 return pyobj;
18265 }
18266
18267
18268 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18269 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18270 return 1;
18271 }
18272
18273
18274 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18275 PyObject *pyobj = 0;
18276
18277 {
18278 #if wxUSE_UNICODE
18279 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18280 #else
18281 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18282 #endif
18283 }
18284 return pyobj;
18285 }
18286
18287
18288 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18289 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18290 return 1;
18291 }
18292
18293
18294 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18295 PyObject *pyobj = 0;
18296
18297 {
18298 #if wxUSE_UNICODE
18299 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18300 #else
18301 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18302 #endif
18303 }
18304 return pyobj;
18305 }
18306
18307
18308 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18309 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18310 return 1;
18311 }
18312
18313
18314 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18315 PyObject *pyobj = 0;
18316
18317 {
18318 #if wxUSE_UNICODE
18319 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18320 #else
18321 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18322 #endif
18323 }
18324 return pyobj;
18325 }
18326
18327
18328 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18329 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18330 return 1;
18331 }
18332
18333
18334 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18335 PyObject *pyobj = 0;
18336
18337 {
18338 #if wxUSE_UNICODE
18339 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18340 #else
18341 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18342 #endif
18343 }
18344 return pyobj;
18345 }
18346
18347
18348 SWIGINTERN int ART_OTHER_set(PyObject *) {
18349 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18350 return 1;
18351 }
18352
18353
18354 SWIGINTERN PyObject *ART_OTHER_get(void) {
18355 PyObject *pyobj = 0;
18356
18357 {
18358 #if wxUSE_UNICODE
18359 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18360 #else
18361 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18362 #endif
18363 }
18364 return pyobj;
18365 }
18366
18367
18368 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18369 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18370 return 1;
18371 }
18372
18373
18374 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18375 PyObject *pyobj = 0;
18376
18377 {
18378 #if wxUSE_UNICODE
18379 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18380 #else
18381 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18382 #endif
18383 }
18384 return pyobj;
18385 }
18386
18387
18388 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18389 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18390 return 1;
18391 }
18392
18393
18394 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18395 PyObject *pyobj = 0;
18396
18397 {
18398 #if wxUSE_UNICODE
18399 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18400 #else
18401 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18402 #endif
18403 }
18404 return pyobj;
18405 }
18406
18407
18408 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18409 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18410 return 1;
18411 }
18412
18413
18414 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18415 PyObject *pyobj = 0;
18416
18417 {
18418 #if wxUSE_UNICODE
18419 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18420 #else
18421 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18422 #endif
18423 }
18424 return pyobj;
18425 }
18426
18427
18428 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18429 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18430 return 1;
18431 }
18432
18433
18434 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18435 PyObject *pyobj = 0;
18436
18437 {
18438 #if wxUSE_UNICODE
18439 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18440 #else
18441 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18442 #endif
18443 }
18444 return pyobj;
18445 }
18446
18447
18448 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18449 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18450 return 1;
18451 }
18452
18453
18454 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18455 PyObject *pyobj = 0;
18456
18457 {
18458 #if wxUSE_UNICODE
18459 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18460 #else
18461 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18462 #endif
18463 }
18464 return pyobj;
18465 }
18466
18467
18468 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18469 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18470 return 1;
18471 }
18472
18473
18474 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18475 PyObject *pyobj = 0;
18476
18477 {
18478 #if wxUSE_UNICODE
18479 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18480 #else
18481 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18482 #endif
18483 }
18484 return pyobj;
18485 }
18486
18487
18488 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18489 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18490 return 1;
18491 }
18492
18493
18494 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18495 PyObject *pyobj = 0;
18496
18497 {
18498 #if wxUSE_UNICODE
18499 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18500 #else
18501 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18502 #endif
18503 }
18504 return pyobj;
18505 }
18506
18507
18508 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18509 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18510 return 1;
18511 }
18512
18513
18514 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18515 PyObject *pyobj = 0;
18516
18517 {
18518 #if wxUSE_UNICODE
18519 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18520 #else
18521 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18522 #endif
18523 }
18524 return pyobj;
18525 }
18526
18527
18528 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18529 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18530 return 1;
18531 }
18532
18533
18534 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18535 PyObject *pyobj = 0;
18536
18537 {
18538 #if wxUSE_UNICODE
18539 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18540 #else
18541 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18542 #endif
18543 }
18544 return pyobj;
18545 }
18546
18547
18548 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18549 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18550 return 1;
18551 }
18552
18553
18554 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18555 PyObject *pyobj = 0;
18556
18557 {
18558 #if wxUSE_UNICODE
18559 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18560 #else
18561 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18562 #endif
18563 }
18564 return pyobj;
18565 }
18566
18567
18568 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18569 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18570 return 1;
18571 }
18572
18573
18574 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18575 PyObject *pyobj = 0;
18576
18577 {
18578 #if wxUSE_UNICODE
18579 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18580 #else
18581 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18582 #endif
18583 }
18584 return pyobj;
18585 }
18586
18587
18588 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18589 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18590 return 1;
18591 }
18592
18593
18594 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18595 PyObject *pyobj = 0;
18596
18597 {
18598 #if wxUSE_UNICODE
18599 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18600 #else
18601 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18602 #endif
18603 }
18604 return pyobj;
18605 }
18606
18607
18608 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18609 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18610 return 1;
18611 }
18612
18613
18614 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18615 PyObject *pyobj = 0;
18616
18617 {
18618 #if wxUSE_UNICODE
18619 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18620 #else
18621 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18622 #endif
18623 }
18624 return pyobj;
18625 }
18626
18627
18628 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18629 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18630 return 1;
18631 }
18632
18633
18634 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18635 PyObject *pyobj = 0;
18636
18637 {
18638 #if wxUSE_UNICODE
18639 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18640 #else
18641 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18642 #endif
18643 }
18644 return pyobj;
18645 }
18646
18647
18648 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18649 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18650 return 1;
18651 }
18652
18653
18654 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18655 PyObject *pyobj = 0;
18656
18657 {
18658 #if wxUSE_UNICODE
18659 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18660 #else
18661 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18662 #endif
18663 }
18664 return pyobj;
18665 }
18666
18667
18668 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18669 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18670 return 1;
18671 }
18672
18673
18674 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18675 PyObject *pyobj = 0;
18676
18677 {
18678 #if wxUSE_UNICODE
18679 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18680 #else
18681 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18682 #endif
18683 }
18684 return pyobj;
18685 }
18686
18687
18688 SWIGINTERN int ART_PRINT_set(PyObject *) {
18689 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18690 return 1;
18691 }
18692
18693
18694 SWIGINTERN PyObject *ART_PRINT_get(void) {
18695 PyObject *pyobj = 0;
18696
18697 {
18698 #if wxUSE_UNICODE
18699 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18700 #else
18701 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18702 #endif
18703 }
18704 return pyobj;
18705 }
18706
18707
18708 SWIGINTERN int ART_HELP_set(PyObject *) {
18709 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18710 return 1;
18711 }
18712
18713
18714 SWIGINTERN PyObject *ART_HELP_get(void) {
18715 PyObject *pyobj = 0;
18716
18717 {
18718 #if wxUSE_UNICODE
18719 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18720 #else
18721 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18722 #endif
18723 }
18724 return pyobj;
18725 }
18726
18727
18728 SWIGINTERN int ART_TIP_set(PyObject *) {
18729 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18730 return 1;
18731 }
18732
18733
18734 SWIGINTERN PyObject *ART_TIP_get(void) {
18735 PyObject *pyobj = 0;
18736
18737 {
18738 #if wxUSE_UNICODE
18739 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18740 #else
18741 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18742 #endif
18743 }
18744 return pyobj;
18745 }
18746
18747
18748 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18749 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18750 return 1;
18751 }
18752
18753
18754 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18755 PyObject *pyobj = 0;
18756
18757 {
18758 #if wxUSE_UNICODE
18759 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18760 #else
18761 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18762 #endif
18763 }
18764 return pyobj;
18765 }
18766
18767
18768 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18769 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18770 return 1;
18771 }
18772
18773
18774 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18775 PyObject *pyobj = 0;
18776
18777 {
18778 #if wxUSE_UNICODE
18779 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18780 #else
18781 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18782 #endif
18783 }
18784 return pyobj;
18785 }
18786
18787
18788 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18789 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18790 return 1;
18791 }
18792
18793
18794 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18795 PyObject *pyobj = 0;
18796
18797 {
18798 #if wxUSE_UNICODE
18799 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18800 #else
18801 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18802 #endif
18803 }
18804 return pyobj;
18805 }
18806
18807
18808 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18809 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18810 return 1;
18811 }
18812
18813
18814 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18815 PyObject *pyobj = 0;
18816
18817 {
18818 #if wxUSE_UNICODE
18819 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18820 #else
18821 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18822 #endif
18823 }
18824 return pyobj;
18825 }
18826
18827
18828 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18829 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18830 return 1;
18831 }
18832
18833
18834 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18835 PyObject *pyobj = 0;
18836
18837 {
18838 #if wxUSE_UNICODE
18839 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18840 #else
18841 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18842 #endif
18843 }
18844 return pyobj;
18845 }
18846
18847
18848 SWIGINTERN int ART_CDROM_set(PyObject *) {
18849 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18850 return 1;
18851 }
18852
18853
18854 SWIGINTERN PyObject *ART_CDROM_get(void) {
18855 PyObject *pyobj = 0;
18856
18857 {
18858 #if wxUSE_UNICODE
18859 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18860 #else
18861 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18862 #endif
18863 }
18864 return pyobj;
18865 }
18866
18867
18868 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18869 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18870 return 1;
18871 }
18872
18873
18874 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18875 PyObject *pyobj = 0;
18876
18877 {
18878 #if wxUSE_UNICODE
18879 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18880 #else
18881 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18882 #endif
18883 }
18884 return pyobj;
18885 }
18886
18887
18888 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18889 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18890 return 1;
18891 }
18892
18893
18894 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18895 PyObject *pyobj = 0;
18896
18897 {
18898 #if wxUSE_UNICODE
18899 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18900 #else
18901 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18902 #endif
18903 }
18904 return pyobj;
18905 }
18906
18907
18908 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18909 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18910 return 1;
18911 }
18912
18913
18914 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18915 PyObject *pyobj = 0;
18916
18917 {
18918 #if wxUSE_UNICODE
18919 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18920 #else
18921 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18922 #endif
18923 }
18924 return pyobj;
18925 }
18926
18927
18928 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18929 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18930 return 1;
18931 }
18932
18933
18934 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18935 PyObject *pyobj = 0;
18936
18937 {
18938 #if wxUSE_UNICODE
18939 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18940 #else
18941 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18942 #endif
18943 }
18944 return pyobj;
18945 }
18946
18947
18948 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18949 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18950 return 1;
18951 }
18952
18953
18954 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18955 PyObject *pyobj = 0;
18956
18957 {
18958 #if wxUSE_UNICODE
18959 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18960 #else
18961 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18962 #endif
18963 }
18964 return pyobj;
18965 }
18966
18967
18968 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18969 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18970 return 1;
18971 }
18972
18973
18974 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18975 PyObject *pyobj = 0;
18976
18977 {
18978 #if wxUSE_UNICODE
18979 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18980 #else
18981 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18982 #endif
18983 }
18984 return pyobj;
18985 }
18986
18987
18988 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18989 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18990 return 1;
18991 }
18992
18993
18994 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18995 PyObject *pyobj = 0;
18996
18997 {
18998 #if wxUSE_UNICODE
18999 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19000 #else
19001 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
19002 #endif
19003 }
19004 return pyobj;
19005 }
19006
19007
19008 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
19009 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
19010 return 1;
19011 }
19012
19013
19014 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
19015 PyObject *pyobj = 0;
19016
19017 {
19018 #if wxUSE_UNICODE
19019 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19020 #else
19021 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
19022 #endif
19023 }
19024 return pyobj;
19025 }
19026
19027
19028 SWIGINTERN int ART_ERROR_set(PyObject *) {
19029 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
19030 return 1;
19031 }
19032
19033
19034 SWIGINTERN PyObject *ART_ERROR_get(void) {
19035 PyObject *pyobj = 0;
19036
19037 {
19038 #if wxUSE_UNICODE
19039 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19040 #else
19041 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
19042 #endif
19043 }
19044 return pyobj;
19045 }
19046
19047
19048 SWIGINTERN int ART_QUESTION_set(PyObject *) {
19049 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
19050 return 1;
19051 }
19052
19053
19054 SWIGINTERN PyObject *ART_QUESTION_get(void) {
19055 PyObject *pyobj = 0;
19056
19057 {
19058 #if wxUSE_UNICODE
19059 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19060 #else
19061 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
19062 #endif
19063 }
19064 return pyobj;
19065 }
19066
19067
19068 SWIGINTERN int ART_WARNING_set(PyObject *) {
19069 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
19070 return 1;
19071 }
19072
19073
19074 SWIGINTERN PyObject *ART_WARNING_get(void) {
19075 PyObject *pyobj = 0;
19076
19077 {
19078 #if wxUSE_UNICODE
19079 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19080 #else
19081 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
19082 #endif
19083 }
19084 return pyobj;
19085 }
19086
19087
19088 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
19089 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
19090 return 1;
19091 }
19092
19093
19094 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
19095 PyObject *pyobj = 0;
19096
19097 {
19098 #if wxUSE_UNICODE
19099 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19100 #else
19101 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
19102 #endif
19103 }
19104 return pyobj;
19105 }
19106
19107
19108 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
19109 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
19110 return 1;
19111 }
19112
19113
19114 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
19115 PyObject *pyobj = 0;
19116
19117 {
19118 #if wxUSE_UNICODE
19119 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19120 #else
19121 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
19122 #endif
19123 }
19124 return pyobj;
19125 }
19126
19127
19128 SWIGINTERN int ART_COPY_set(PyObject *) {
19129 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
19130 return 1;
19131 }
19132
19133
19134 SWIGINTERN PyObject *ART_COPY_get(void) {
19135 PyObject *pyobj = 0;
19136
19137 {
19138 #if wxUSE_UNICODE
19139 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19140 #else
19141 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
19142 #endif
19143 }
19144 return pyobj;
19145 }
19146
19147
19148 SWIGINTERN int ART_CUT_set(PyObject *) {
19149 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
19150 return 1;
19151 }
19152
19153
19154 SWIGINTERN PyObject *ART_CUT_get(void) {
19155 PyObject *pyobj = 0;
19156
19157 {
19158 #if wxUSE_UNICODE
19159 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19160 #else
19161 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
19162 #endif
19163 }
19164 return pyobj;
19165 }
19166
19167
19168 SWIGINTERN int ART_PASTE_set(PyObject *) {
19169 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
19170 return 1;
19171 }
19172
19173
19174 SWIGINTERN PyObject *ART_PASTE_get(void) {
19175 PyObject *pyobj = 0;
19176
19177 {
19178 #if wxUSE_UNICODE
19179 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19180 #else
19181 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
19182 #endif
19183 }
19184 return pyobj;
19185 }
19186
19187
19188 SWIGINTERN int ART_DELETE_set(PyObject *) {
19189 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
19190 return 1;
19191 }
19192
19193
19194 SWIGINTERN PyObject *ART_DELETE_get(void) {
19195 PyObject *pyobj = 0;
19196
19197 {
19198 #if wxUSE_UNICODE
19199 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19200 #else
19201 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
19202 #endif
19203 }
19204 return pyobj;
19205 }
19206
19207
19208 SWIGINTERN int ART_NEW_set(PyObject *) {
19209 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19210 return 1;
19211 }
19212
19213
19214 SWIGINTERN PyObject *ART_NEW_get(void) {
19215 PyObject *pyobj = 0;
19216
19217 {
19218 #if wxUSE_UNICODE
19219 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19220 #else
19221 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19222 #endif
19223 }
19224 return pyobj;
19225 }
19226
19227
19228 SWIGINTERN int ART_UNDO_set(PyObject *) {
19229 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19230 return 1;
19231 }
19232
19233
19234 SWIGINTERN PyObject *ART_UNDO_get(void) {
19235 PyObject *pyobj = 0;
19236
19237 {
19238 #if wxUSE_UNICODE
19239 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19240 #else
19241 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19242 #endif
19243 }
19244 return pyobj;
19245 }
19246
19247
19248 SWIGINTERN int ART_REDO_set(PyObject *) {
19249 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19250 return 1;
19251 }
19252
19253
19254 SWIGINTERN PyObject *ART_REDO_get(void) {
19255 PyObject *pyobj = 0;
19256
19257 {
19258 #if wxUSE_UNICODE
19259 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19260 #else
19261 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19262 #endif
19263 }
19264 return pyobj;
19265 }
19266
19267
19268 SWIGINTERN int ART_QUIT_set(PyObject *) {
19269 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19270 return 1;
19271 }
19272
19273
19274 SWIGINTERN PyObject *ART_QUIT_get(void) {
19275 PyObject *pyobj = 0;
19276
19277 {
19278 #if wxUSE_UNICODE
19279 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19280 #else
19281 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19282 #endif
19283 }
19284 return pyobj;
19285 }
19286
19287
19288 SWIGINTERN int ART_FIND_set(PyObject *) {
19289 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19290 return 1;
19291 }
19292
19293
19294 SWIGINTERN PyObject *ART_FIND_get(void) {
19295 PyObject *pyobj = 0;
19296
19297 {
19298 #if wxUSE_UNICODE
19299 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19300 #else
19301 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19302 #endif
19303 }
19304 return pyobj;
19305 }
19306
19307
19308 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19309 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19310 return 1;
19311 }
19312
19313
19314 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19315 PyObject *pyobj = 0;
19316
19317 {
19318 #if wxUSE_UNICODE
19319 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19320 #else
19321 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19322 #endif
19323 }
19324 return pyobj;
19325 }
19326
19327
19328 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19329 PyObject *resultobj = 0;
19330 wxPyArtProvider *result = 0 ;
19331
19332 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19333 {
19334 if (!wxPyCheckForApp()) SWIG_fail;
19335 PyThreadState* __tstate = wxPyBeginAllowThreads();
19336 result = (wxPyArtProvider *)new wxPyArtProvider();
19337 wxPyEndAllowThreads(__tstate);
19338 if (PyErr_Occurred()) SWIG_fail;
19339 }
19340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19341 return resultobj;
19342 fail:
19343 return NULL;
19344 }
19345
19346
19347 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19348 PyObject *resultobj = 0;
19349 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19350 void *argp1 = 0 ;
19351 int res1 = 0 ;
19352 PyObject *swig_obj[1] ;
19353
19354 if (!args) SWIG_fail;
19355 swig_obj[0] = args;
19356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19357 if (!SWIG_IsOK(res1)) {
19358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19359 }
19360 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19361 {
19362 PyThreadState* __tstate = wxPyBeginAllowThreads();
19363 delete arg1;
19364
19365 wxPyEndAllowThreads(__tstate);
19366 if (PyErr_Occurred()) SWIG_fail;
19367 }
19368 resultobj = SWIG_Py_Void();
19369 return resultobj;
19370 fail:
19371 return NULL;
19372 }
19373
19374
19375 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19376 PyObject *resultobj = 0;
19377 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19378 PyObject *arg2 = (PyObject *) 0 ;
19379 PyObject *arg3 = (PyObject *) 0 ;
19380 void *argp1 = 0 ;
19381 int res1 = 0 ;
19382 PyObject * obj0 = 0 ;
19383 PyObject * obj1 = 0 ;
19384 PyObject * obj2 = 0 ;
19385 char * kwnames[] = {
19386 (char *) "self",(char *) "self",(char *) "_class", NULL
19387 };
19388
19389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19391 if (!SWIG_IsOK(res1)) {
19392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19393 }
19394 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19395 arg2 = obj1;
19396 arg3 = obj2;
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 (arg1)->_setCallbackInfo(arg2,arg3);
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 resultobj = SWIG_Py_Void();
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19411 PyObject *resultobj = 0;
19412 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19413 int res1 = 0 ;
19414 PyObject * obj0 = 0 ;
19415 char * kwnames[] = {
19416 (char *) "provider", NULL
19417 };
19418
19419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19420 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19421 if (!SWIG_IsOK(res1)) {
19422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19423 }
19424 {
19425 PyThreadState* __tstate = wxPyBeginAllowThreads();
19426 wxPyArtProvider::PushProvider(arg1);
19427 wxPyEndAllowThreads(__tstate);
19428 if (PyErr_Occurred()) SWIG_fail;
19429 }
19430 resultobj = SWIG_Py_Void();
19431 return resultobj;
19432 fail:
19433 return NULL;
19434 }
19435
19436
19437 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19438 PyObject *resultobj = 0;
19439 bool result;
19440
19441 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19442 {
19443 PyThreadState* __tstate = wxPyBeginAllowThreads();
19444 result = (bool)wxPyArtProvider::PopProvider();
19445 wxPyEndAllowThreads(__tstate);
19446 if (PyErr_Occurred()) SWIG_fail;
19447 }
19448 {
19449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19450 }
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19458 PyObject *resultobj = 0;
19459 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19460 bool result;
19461 void *argp1 = 0 ;
19462 int res1 = 0 ;
19463 PyObject * obj0 = 0 ;
19464 char * kwnames[] = {
19465 (char *) "provider", NULL
19466 };
19467
19468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19470 if (!SWIG_IsOK(res1)) {
19471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19472 }
19473 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19477 wxPyEndAllowThreads(__tstate);
19478 if (PyErr_Occurred()) SWIG_fail;
19479 }
19480 {
19481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19482 }
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19490 PyObject *resultobj = 0;
19491 wxString *arg1 = 0 ;
19492 wxString const &arg2_defvalue = wxPyART_OTHER ;
19493 wxString *arg2 = (wxString *) &arg2_defvalue ;
19494 wxSize const &arg3_defvalue = wxDefaultSize ;
19495 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19496 wxBitmap result;
19497 bool temp1 = false ;
19498 bool temp2 = false ;
19499 wxSize temp3 ;
19500 PyObject * obj0 = 0 ;
19501 PyObject * obj1 = 0 ;
19502 PyObject * obj2 = 0 ;
19503 char * kwnames[] = {
19504 (char *) "id",(char *) "client",(char *) "size", NULL
19505 };
19506
19507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19508 {
19509 arg1 = wxString_in_helper(obj0);
19510 if (arg1 == NULL) SWIG_fail;
19511 temp1 = true;
19512 }
19513 if (obj1) {
19514 {
19515 arg2 = wxString_in_helper(obj1);
19516 if (arg2 == NULL) SWIG_fail;
19517 temp2 = true;
19518 }
19519 }
19520 if (obj2) {
19521 {
19522 arg3 = &temp3;
19523 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19524 }
19525 }
19526 {
19527 if (!wxPyCheckForApp()) SWIG_fail;
19528 PyThreadState* __tstate = wxPyBeginAllowThreads();
19529 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19530 wxPyEndAllowThreads(__tstate);
19531 if (PyErr_Occurred()) SWIG_fail;
19532 }
19533 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19534 {
19535 if (temp1)
19536 delete arg1;
19537 }
19538 {
19539 if (temp2)
19540 delete arg2;
19541 }
19542 return resultobj;
19543 fail:
19544 {
19545 if (temp1)
19546 delete arg1;
19547 }
19548 {
19549 if (temp2)
19550 delete arg2;
19551 }
19552 return NULL;
19553 }
19554
19555
19556 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19557 PyObject *resultobj = 0;
19558 wxString *arg1 = 0 ;
19559 wxString const &arg2_defvalue = wxPyART_OTHER ;
19560 wxString *arg2 = (wxString *) &arg2_defvalue ;
19561 wxSize const &arg3_defvalue = wxDefaultSize ;
19562 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19563 wxIcon result;
19564 bool temp1 = false ;
19565 bool temp2 = false ;
19566 wxSize temp3 ;
19567 PyObject * obj0 = 0 ;
19568 PyObject * obj1 = 0 ;
19569 PyObject * obj2 = 0 ;
19570 char * kwnames[] = {
19571 (char *) "id",(char *) "client",(char *) "size", NULL
19572 };
19573
19574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19575 {
19576 arg1 = wxString_in_helper(obj0);
19577 if (arg1 == NULL) SWIG_fail;
19578 temp1 = true;
19579 }
19580 if (obj1) {
19581 {
19582 arg2 = wxString_in_helper(obj1);
19583 if (arg2 == NULL) SWIG_fail;
19584 temp2 = true;
19585 }
19586 }
19587 if (obj2) {
19588 {
19589 arg3 = &temp3;
19590 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19591 }
19592 }
19593 {
19594 if (!wxPyCheckForApp()) SWIG_fail;
19595 PyThreadState* __tstate = wxPyBeginAllowThreads();
19596 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19597 wxPyEndAllowThreads(__tstate);
19598 if (PyErr_Occurred()) SWIG_fail;
19599 }
19600 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19601 {
19602 if (temp1)
19603 delete arg1;
19604 }
19605 {
19606 if (temp2)
19607 delete arg2;
19608 }
19609 return resultobj;
19610 fail:
19611 {
19612 if (temp1)
19613 delete arg1;
19614 }
19615 {
19616 if (temp2)
19617 delete arg2;
19618 }
19619 return NULL;
19620 }
19621
19622
19623 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19624 PyObject *resultobj = 0;
19625 wxString *arg1 = 0 ;
19626 bool arg2 = (bool) false ;
19627 wxSize result;
19628 bool temp1 = false ;
19629 bool val2 ;
19630 int ecode2 = 0 ;
19631 PyObject * obj0 = 0 ;
19632 PyObject * obj1 = 0 ;
19633 char * kwnames[] = {
19634 (char *) "client",(char *) "platform_dependent", NULL
19635 };
19636
19637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19638 {
19639 arg1 = wxString_in_helper(obj0);
19640 if (arg1 == NULL) SWIG_fail;
19641 temp1 = true;
19642 }
19643 if (obj1) {
19644 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19645 if (!SWIG_IsOK(ecode2)) {
19646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19647 }
19648 arg2 = static_cast< bool >(val2);
19649 }
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19657 {
19658 if (temp1)
19659 delete arg1;
19660 }
19661 return resultobj;
19662 fail:
19663 {
19664 if (temp1)
19665 delete arg1;
19666 }
19667 return NULL;
19668 }
19669
19670
19671 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19672 PyObject *resultobj = 0;
19673 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19674 void *argp1 = 0 ;
19675 int res1 = 0 ;
19676 PyObject *swig_obj[1] ;
19677
19678 if (!args) SWIG_fail;
19679 swig_obj[0] = args;
19680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19681 if (!SWIG_IsOK(res1)) {
19682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19683 }
19684 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 wxPyArtProvider_Destroy(arg1);
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 resultobj = SWIG_Py_Void();
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19699 PyObject *obj;
19700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19701 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19702 return SWIG_Py_Void();
19703 }
19704
19705 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19706 return SWIG_Python_InitShadowInstance(args);
19707 }
19708
19709 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19710 PyObject *resultobj = 0;
19711 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19712 void *argp1 = 0 ;
19713 int res1 = 0 ;
19714 PyObject *swig_obj[1] ;
19715
19716 if (!args) SWIG_fail;
19717 swig_obj[0] = args;
19718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19719 if (!SWIG_IsOK(res1)) {
19720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19721 }
19722 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19723 {
19724 PyThreadState* __tstate = wxPyBeginAllowThreads();
19725 delete arg1;
19726
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 resultobj = SWIG_Py_Void();
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj = 0;
19739 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19740 wxConfigBase *result = 0 ;
19741 int res1 = 0 ;
19742 PyObject * obj0 = 0 ;
19743 char * kwnames[] = {
19744 (char *) "config", NULL
19745 };
19746
19747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19748 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19749 if (!SWIG_IsOK(res1)) {
19750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19751 }
19752 {
19753 PyThreadState* __tstate = wxPyBeginAllowThreads();
19754 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19755 wxPyEndAllowThreads(__tstate);
19756 if (PyErr_Occurred()) SWIG_fail;
19757 }
19758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19759 return resultobj;
19760 fail:
19761 return NULL;
19762 }
19763
19764
19765 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19766 PyObject *resultobj = 0;
19767 bool arg1 = (bool) true ;
19768 wxConfigBase *result = 0 ;
19769 bool val1 ;
19770 int ecode1 = 0 ;
19771 PyObject * obj0 = 0 ;
19772 char * kwnames[] = {
19773 (char *) "createOnDemand", NULL
19774 };
19775
19776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19777 if (obj0) {
19778 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19779 if (!SWIG_IsOK(ecode1)) {
19780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19781 }
19782 arg1 = static_cast< bool >(val1);
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19798 PyObject *resultobj = 0;
19799 wxConfigBase *result = 0 ;
19800
19801 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19802 {
19803 PyThreadState* __tstate = wxPyBeginAllowThreads();
19804 result = (wxConfigBase *)wxConfigBase::Create();
19805 wxPyEndAllowThreads(__tstate);
19806 if (PyErr_Occurred()) SWIG_fail;
19807 }
19808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19809 return resultobj;
19810 fail:
19811 return NULL;
19812 }
19813
19814
19815 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19816 PyObject *resultobj = 0;
19817
19818 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19819 {
19820 PyThreadState* __tstate = wxPyBeginAllowThreads();
19821 wxConfigBase::DontCreateOnDemand();
19822 wxPyEndAllowThreads(__tstate);
19823 if (PyErr_Occurred()) SWIG_fail;
19824 }
19825 resultobj = SWIG_Py_Void();
19826 return resultobj;
19827 fail:
19828 return NULL;
19829 }
19830
19831
19832 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19833 PyObject *resultobj = 0;
19834 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19835 wxString *arg2 = 0 ;
19836 void *argp1 = 0 ;
19837 int res1 = 0 ;
19838 bool temp2 = false ;
19839 PyObject * obj0 = 0 ;
19840 PyObject * obj1 = 0 ;
19841 char * kwnames[] = {
19842 (char *) "self",(char *) "path", NULL
19843 };
19844
19845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19847 if (!SWIG_IsOK(res1)) {
19848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19849 }
19850 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19851 {
19852 arg2 = wxString_in_helper(obj1);
19853 if (arg2 == NULL) SWIG_fail;
19854 temp2 = true;
19855 }
19856 {
19857 PyThreadState* __tstate = wxPyBeginAllowThreads();
19858 (arg1)->SetPath((wxString const &)*arg2);
19859 wxPyEndAllowThreads(__tstate);
19860 if (PyErr_Occurred()) SWIG_fail;
19861 }
19862 resultobj = SWIG_Py_Void();
19863 {
19864 if (temp2)
19865 delete arg2;
19866 }
19867 return resultobj;
19868 fail:
19869 {
19870 if (temp2)
19871 delete arg2;
19872 }
19873 return NULL;
19874 }
19875
19876
19877 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19878 PyObject *resultobj = 0;
19879 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19880 wxString *result = 0 ;
19881 void *argp1 = 0 ;
19882 int res1 = 0 ;
19883 PyObject *swig_obj[1] ;
19884
19885 if (!args) SWIG_fail;
19886 swig_obj[0] = args;
19887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19888 if (!SWIG_IsOK(res1)) {
19889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19890 }
19891 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19892 {
19893 PyThreadState* __tstate = wxPyBeginAllowThreads();
19894 {
19895 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19896 result = (wxString *) &_result_ref;
19897 }
19898 wxPyEndAllowThreads(__tstate);
19899 if (PyErr_Occurred()) SWIG_fail;
19900 }
19901 {
19902 #if wxUSE_UNICODE
19903 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19904 #else
19905 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19906 #endif
19907 }
19908 return resultobj;
19909 fail:
19910 return NULL;
19911 }
19912
19913
19914 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19915 PyObject *resultobj = 0;
19916 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19917 PyObject *result = 0 ;
19918 void *argp1 = 0 ;
19919 int res1 = 0 ;
19920 PyObject *swig_obj[1] ;
19921
19922 if (!args) SWIG_fail;
19923 swig_obj[0] = args;
19924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19925 if (!SWIG_IsOK(res1)) {
19926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19927 }
19928 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19929 {
19930 PyThreadState* __tstate = wxPyBeginAllowThreads();
19931 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19932 wxPyEndAllowThreads(__tstate);
19933 if (PyErr_Occurred()) SWIG_fail;
19934 }
19935 resultobj = result;
19936 return resultobj;
19937 fail:
19938 return NULL;
19939 }
19940
19941
19942 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19943 PyObject *resultobj = 0;
19944 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19945 long arg2 ;
19946 PyObject *result = 0 ;
19947 void *argp1 = 0 ;
19948 int res1 = 0 ;
19949 long val2 ;
19950 int ecode2 = 0 ;
19951 PyObject * obj0 = 0 ;
19952 PyObject * obj1 = 0 ;
19953 char * kwnames[] = {
19954 (char *) "self",(char *) "index", NULL
19955 };
19956
19957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19959 if (!SWIG_IsOK(res1)) {
19960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19961 }
19962 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19963 ecode2 = SWIG_AsVal_long(obj1, &val2);
19964 if (!SWIG_IsOK(ecode2)) {
19965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19966 }
19967 arg2 = static_cast< long >(val2);
19968 {
19969 PyThreadState* __tstate = wxPyBeginAllowThreads();
19970 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 resultobj = result;
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19982 PyObject *resultobj = 0;
19983 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19984 PyObject *result = 0 ;
19985 void *argp1 = 0 ;
19986 int res1 = 0 ;
19987 PyObject *swig_obj[1] ;
19988
19989 if (!args) SWIG_fail;
19990 swig_obj[0] = args;
19991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19992 if (!SWIG_IsOK(res1)) {
19993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19994 }
19995 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19996 {
19997 PyThreadState* __tstate = wxPyBeginAllowThreads();
19998 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19999 wxPyEndAllowThreads(__tstate);
20000 if (PyErr_Occurred()) SWIG_fail;
20001 }
20002 resultobj = result;
20003 return resultobj;
20004 fail:
20005 return NULL;
20006 }
20007
20008
20009 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20010 PyObject *resultobj = 0;
20011 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20012 long arg2 ;
20013 PyObject *result = 0 ;
20014 void *argp1 = 0 ;
20015 int res1 = 0 ;
20016 long val2 ;
20017 int ecode2 = 0 ;
20018 PyObject * obj0 = 0 ;
20019 PyObject * obj1 = 0 ;
20020 char * kwnames[] = {
20021 (char *) "self",(char *) "index", NULL
20022 };
20023
20024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20026 if (!SWIG_IsOK(res1)) {
20027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20028 }
20029 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20030 ecode2 = SWIG_AsVal_long(obj1, &val2);
20031 if (!SWIG_IsOK(ecode2)) {
20032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
20033 }
20034 arg2 = static_cast< long >(val2);
20035 {
20036 PyThreadState* __tstate = wxPyBeginAllowThreads();
20037 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
20038 wxPyEndAllowThreads(__tstate);
20039 if (PyErr_Occurred()) SWIG_fail;
20040 }
20041 resultobj = result;
20042 return resultobj;
20043 fail:
20044 return NULL;
20045 }
20046
20047
20048 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20049 PyObject *resultobj = 0;
20050 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20051 bool arg2 = (bool) false ;
20052 size_t result;
20053 void *argp1 = 0 ;
20054 int res1 = 0 ;
20055 bool val2 ;
20056 int ecode2 = 0 ;
20057 PyObject * obj0 = 0 ;
20058 PyObject * obj1 = 0 ;
20059 char * kwnames[] = {
20060 (char *) "self",(char *) "recursive", NULL
20061 };
20062
20063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
20064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20065 if (!SWIG_IsOK(res1)) {
20066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20067 }
20068 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20069 if (obj1) {
20070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20071 if (!SWIG_IsOK(ecode2)) {
20072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
20073 }
20074 arg2 = static_cast< bool >(val2);
20075 }
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
20079 wxPyEndAllowThreads(__tstate);
20080 if (PyErr_Occurred()) SWIG_fail;
20081 }
20082 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20090 PyObject *resultobj = 0;
20091 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20092 bool arg2 = (bool) false ;
20093 size_t result;
20094 void *argp1 = 0 ;
20095 int res1 = 0 ;
20096 bool val2 ;
20097 int ecode2 = 0 ;
20098 PyObject * obj0 = 0 ;
20099 PyObject * obj1 = 0 ;
20100 char * kwnames[] = {
20101 (char *) "self",(char *) "recursive", NULL
20102 };
20103
20104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
20105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20106 if (!SWIG_IsOK(res1)) {
20107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20108 }
20109 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20110 if (obj1) {
20111 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20112 if (!SWIG_IsOK(ecode2)) {
20113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
20114 }
20115 arg2 = static_cast< bool >(val2);
20116 }
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
20124 return resultobj;
20125 fail:
20126 return NULL;
20127 }
20128
20129
20130 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20131 PyObject *resultobj = 0;
20132 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20133 wxString *arg2 = 0 ;
20134 bool result;
20135 void *argp1 = 0 ;
20136 int res1 = 0 ;
20137 bool temp2 = false ;
20138 PyObject * obj0 = 0 ;
20139 PyObject * obj1 = 0 ;
20140 char * kwnames[] = {
20141 (char *) "self",(char *) "name", NULL
20142 };
20143
20144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20146 if (!SWIG_IsOK(res1)) {
20147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20148 }
20149 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20150 {
20151 arg2 = wxString_in_helper(obj1);
20152 if (arg2 == NULL) SWIG_fail;
20153 temp2 = true;
20154 }
20155 {
20156 PyThreadState* __tstate = wxPyBeginAllowThreads();
20157 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
20158 wxPyEndAllowThreads(__tstate);
20159 if (PyErr_Occurred()) SWIG_fail;
20160 }
20161 {
20162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20163 }
20164 {
20165 if (temp2)
20166 delete arg2;
20167 }
20168 return resultobj;
20169 fail:
20170 {
20171 if (temp2)
20172 delete arg2;
20173 }
20174 return NULL;
20175 }
20176
20177
20178 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20179 PyObject *resultobj = 0;
20180 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20181 wxString *arg2 = 0 ;
20182 bool result;
20183 void *argp1 = 0 ;
20184 int res1 = 0 ;
20185 bool temp2 = false ;
20186 PyObject * obj0 = 0 ;
20187 PyObject * obj1 = 0 ;
20188 char * kwnames[] = {
20189 (char *) "self",(char *) "name", NULL
20190 };
20191
20192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
20193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20194 if (!SWIG_IsOK(res1)) {
20195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20196 }
20197 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20198 {
20199 arg2 = wxString_in_helper(obj1);
20200 if (arg2 == NULL) SWIG_fail;
20201 temp2 = true;
20202 }
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20206 wxPyEndAllowThreads(__tstate);
20207 if (PyErr_Occurred()) SWIG_fail;
20208 }
20209 {
20210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20211 }
20212 {
20213 if (temp2)
20214 delete arg2;
20215 }
20216 return resultobj;
20217 fail:
20218 {
20219 if (temp2)
20220 delete arg2;
20221 }
20222 return NULL;
20223 }
20224
20225
20226 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20227 PyObject *resultobj = 0;
20228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20229 wxString *arg2 = 0 ;
20230 bool result;
20231 void *argp1 = 0 ;
20232 int res1 = 0 ;
20233 bool temp2 = false ;
20234 PyObject * obj0 = 0 ;
20235 PyObject * obj1 = 0 ;
20236 char * kwnames[] = {
20237 (char *) "self",(char *) "name", NULL
20238 };
20239
20240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20242 if (!SWIG_IsOK(res1)) {
20243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20244 }
20245 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20246 {
20247 arg2 = wxString_in_helper(obj1);
20248 if (arg2 == NULL) SWIG_fail;
20249 temp2 = true;
20250 }
20251 {
20252 PyThreadState* __tstate = wxPyBeginAllowThreads();
20253 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20254 wxPyEndAllowThreads(__tstate);
20255 if (PyErr_Occurred()) SWIG_fail;
20256 }
20257 {
20258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20259 }
20260 {
20261 if (temp2)
20262 delete arg2;
20263 }
20264 return resultobj;
20265 fail:
20266 {
20267 if (temp2)
20268 delete arg2;
20269 }
20270 return NULL;
20271 }
20272
20273
20274 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20275 PyObject *resultobj = 0;
20276 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20277 wxString *arg2 = 0 ;
20278 wxConfigBase::EntryType result;
20279 void *argp1 = 0 ;
20280 int res1 = 0 ;
20281 bool temp2 = false ;
20282 PyObject * obj0 = 0 ;
20283 PyObject * obj1 = 0 ;
20284 char * kwnames[] = {
20285 (char *) "self",(char *) "name", NULL
20286 };
20287
20288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20290 if (!SWIG_IsOK(res1)) {
20291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20292 }
20293 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20294 {
20295 arg2 = wxString_in_helper(obj1);
20296 if (arg2 == NULL) SWIG_fail;
20297 temp2 = true;
20298 }
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20302 wxPyEndAllowThreads(__tstate);
20303 if (PyErr_Occurred()) SWIG_fail;
20304 }
20305 resultobj = SWIG_From_int(static_cast< int >(result));
20306 {
20307 if (temp2)
20308 delete arg2;
20309 }
20310 return resultobj;
20311 fail:
20312 {
20313 if (temp2)
20314 delete arg2;
20315 }
20316 return NULL;
20317 }
20318
20319
20320 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20321 PyObject *resultobj = 0;
20322 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20323 wxString *arg2 = 0 ;
20324 wxString const &arg3_defvalue = wxPyEmptyString ;
20325 wxString *arg3 = (wxString *) &arg3_defvalue ;
20326 wxString result;
20327 void *argp1 = 0 ;
20328 int res1 = 0 ;
20329 bool temp2 = false ;
20330 bool temp3 = false ;
20331 PyObject * obj0 = 0 ;
20332 PyObject * obj1 = 0 ;
20333 PyObject * obj2 = 0 ;
20334 char * kwnames[] = {
20335 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20336 };
20337
20338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20340 if (!SWIG_IsOK(res1)) {
20341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20342 }
20343 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20344 {
20345 arg2 = wxString_in_helper(obj1);
20346 if (arg2 == NULL) SWIG_fail;
20347 temp2 = true;
20348 }
20349 if (obj2) {
20350 {
20351 arg3 = wxString_in_helper(obj2);
20352 if (arg3 == NULL) SWIG_fail;
20353 temp3 = true;
20354 }
20355 }
20356 {
20357 PyThreadState* __tstate = wxPyBeginAllowThreads();
20358 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20359 wxPyEndAllowThreads(__tstate);
20360 if (PyErr_Occurred()) SWIG_fail;
20361 }
20362 {
20363 #if wxUSE_UNICODE
20364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20365 #else
20366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20367 #endif
20368 }
20369 {
20370 if (temp2)
20371 delete arg2;
20372 }
20373 {
20374 if (temp3)
20375 delete arg3;
20376 }
20377 return resultobj;
20378 fail:
20379 {
20380 if (temp2)
20381 delete arg2;
20382 }
20383 {
20384 if (temp3)
20385 delete arg3;
20386 }
20387 return NULL;
20388 }
20389
20390
20391 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20392 PyObject *resultobj = 0;
20393 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20394 wxString *arg2 = 0 ;
20395 long arg3 = (long) 0 ;
20396 long result;
20397 void *argp1 = 0 ;
20398 int res1 = 0 ;
20399 bool temp2 = false ;
20400 long val3 ;
20401 int ecode3 = 0 ;
20402 PyObject * obj0 = 0 ;
20403 PyObject * obj1 = 0 ;
20404 PyObject * obj2 = 0 ;
20405 char * kwnames[] = {
20406 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20407 };
20408
20409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20411 if (!SWIG_IsOK(res1)) {
20412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20413 }
20414 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20415 {
20416 arg2 = wxString_in_helper(obj1);
20417 if (arg2 == NULL) SWIG_fail;
20418 temp2 = true;
20419 }
20420 if (obj2) {
20421 ecode3 = SWIG_AsVal_long(obj2, &val3);
20422 if (!SWIG_IsOK(ecode3)) {
20423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20424 }
20425 arg3 = static_cast< long >(val3);
20426 }
20427 {
20428 PyThreadState* __tstate = wxPyBeginAllowThreads();
20429 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20430 wxPyEndAllowThreads(__tstate);
20431 if (PyErr_Occurred()) SWIG_fail;
20432 }
20433 resultobj = SWIG_From_long(static_cast< long >(result));
20434 {
20435 if (temp2)
20436 delete arg2;
20437 }
20438 return resultobj;
20439 fail:
20440 {
20441 if (temp2)
20442 delete arg2;
20443 }
20444 return NULL;
20445 }
20446
20447
20448 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20449 PyObject *resultobj = 0;
20450 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20451 wxString *arg2 = 0 ;
20452 double arg3 = (double) 0.0 ;
20453 double result;
20454 void *argp1 = 0 ;
20455 int res1 = 0 ;
20456 bool temp2 = false ;
20457 double val3 ;
20458 int ecode3 = 0 ;
20459 PyObject * obj0 = 0 ;
20460 PyObject * obj1 = 0 ;
20461 PyObject * obj2 = 0 ;
20462 char * kwnames[] = {
20463 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20464 };
20465
20466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20468 if (!SWIG_IsOK(res1)) {
20469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20470 }
20471 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20472 {
20473 arg2 = wxString_in_helper(obj1);
20474 if (arg2 == NULL) SWIG_fail;
20475 temp2 = true;
20476 }
20477 if (obj2) {
20478 ecode3 = SWIG_AsVal_double(obj2, &val3);
20479 if (!SWIG_IsOK(ecode3)) {
20480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20481 }
20482 arg3 = static_cast< double >(val3);
20483 }
20484 {
20485 PyThreadState* __tstate = wxPyBeginAllowThreads();
20486 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20487 wxPyEndAllowThreads(__tstate);
20488 if (PyErr_Occurred()) SWIG_fail;
20489 }
20490 resultobj = SWIG_From_double(static_cast< double >(result));
20491 {
20492 if (temp2)
20493 delete arg2;
20494 }
20495 return resultobj;
20496 fail:
20497 {
20498 if (temp2)
20499 delete arg2;
20500 }
20501 return NULL;
20502 }
20503
20504
20505 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20506 PyObject *resultobj = 0;
20507 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20508 wxString *arg2 = 0 ;
20509 bool arg3 = (bool) false ;
20510 bool result;
20511 void *argp1 = 0 ;
20512 int res1 = 0 ;
20513 bool temp2 = false ;
20514 bool val3 ;
20515 int ecode3 = 0 ;
20516 PyObject * obj0 = 0 ;
20517 PyObject * obj1 = 0 ;
20518 PyObject * obj2 = 0 ;
20519 char * kwnames[] = {
20520 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20521 };
20522
20523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20525 if (!SWIG_IsOK(res1)) {
20526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20527 }
20528 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20529 {
20530 arg2 = wxString_in_helper(obj1);
20531 if (arg2 == NULL) SWIG_fail;
20532 temp2 = true;
20533 }
20534 if (obj2) {
20535 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20536 if (!SWIG_IsOK(ecode3)) {
20537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20538 }
20539 arg3 = static_cast< bool >(val3);
20540 }
20541 {
20542 PyThreadState* __tstate = wxPyBeginAllowThreads();
20543 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20544 wxPyEndAllowThreads(__tstate);
20545 if (PyErr_Occurred()) SWIG_fail;
20546 }
20547 {
20548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20549 }
20550 {
20551 if (temp2)
20552 delete arg2;
20553 }
20554 return resultobj;
20555 fail:
20556 {
20557 if (temp2)
20558 delete arg2;
20559 }
20560 return NULL;
20561 }
20562
20563
20564 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20565 PyObject *resultobj = 0;
20566 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20567 wxString *arg2 = 0 ;
20568 wxString *arg3 = 0 ;
20569 bool result;
20570 void *argp1 = 0 ;
20571 int res1 = 0 ;
20572 bool temp2 = false ;
20573 bool temp3 = false ;
20574 PyObject * obj0 = 0 ;
20575 PyObject * obj1 = 0 ;
20576 PyObject * obj2 = 0 ;
20577 char * kwnames[] = {
20578 (char *) "self",(char *) "key",(char *) "value", NULL
20579 };
20580
20581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20583 if (!SWIG_IsOK(res1)) {
20584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20585 }
20586 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20587 {
20588 arg2 = wxString_in_helper(obj1);
20589 if (arg2 == NULL) SWIG_fail;
20590 temp2 = true;
20591 }
20592 {
20593 arg3 = wxString_in_helper(obj2);
20594 if (arg3 == NULL) SWIG_fail;
20595 temp3 = true;
20596 }
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 {
20604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20605 }
20606 {
20607 if (temp2)
20608 delete arg2;
20609 }
20610 {
20611 if (temp3)
20612 delete arg3;
20613 }
20614 return resultobj;
20615 fail:
20616 {
20617 if (temp2)
20618 delete arg2;
20619 }
20620 {
20621 if (temp3)
20622 delete arg3;
20623 }
20624 return NULL;
20625 }
20626
20627
20628 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20629 PyObject *resultobj = 0;
20630 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20631 wxString *arg2 = 0 ;
20632 long arg3 ;
20633 bool result;
20634 void *argp1 = 0 ;
20635 int res1 = 0 ;
20636 bool temp2 = false ;
20637 long val3 ;
20638 int ecode3 = 0 ;
20639 PyObject * obj0 = 0 ;
20640 PyObject * obj1 = 0 ;
20641 PyObject * obj2 = 0 ;
20642 char * kwnames[] = {
20643 (char *) "self",(char *) "key",(char *) "value", NULL
20644 };
20645
20646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20648 if (!SWIG_IsOK(res1)) {
20649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20650 }
20651 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20652 {
20653 arg2 = wxString_in_helper(obj1);
20654 if (arg2 == NULL) SWIG_fail;
20655 temp2 = true;
20656 }
20657 ecode3 = SWIG_AsVal_long(obj2, &val3);
20658 if (!SWIG_IsOK(ecode3)) {
20659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20660 }
20661 arg3 = static_cast< long >(val3);
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 {
20669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20670 }
20671 {
20672 if (temp2)
20673 delete arg2;
20674 }
20675 return resultobj;
20676 fail:
20677 {
20678 if (temp2)
20679 delete arg2;
20680 }
20681 return NULL;
20682 }
20683
20684
20685 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20686 PyObject *resultobj = 0;
20687 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20688 wxString *arg2 = 0 ;
20689 double arg3 ;
20690 bool result;
20691 void *argp1 = 0 ;
20692 int res1 = 0 ;
20693 bool temp2 = false ;
20694 double val3 ;
20695 int ecode3 = 0 ;
20696 PyObject * obj0 = 0 ;
20697 PyObject * obj1 = 0 ;
20698 PyObject * obj2 = 0 ;
20699 char * kwnames[] = {
20700 (char *) "self",(char *) "key",(char *) "value", NULL
20701 };
20702
20703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20705 if (!SWIG_IsOK(res1)) {
20706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20707 }
20708 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20709 {
20710 arg2 = wxString_in_helper(obj1);
20711 if (arg2 == NULL) SWIG_fail;
20712 temp2 = true;
20713 }
20714 ecode3 = SWIG_AsVal_double(obj2, &val3);
20715 if (!SWIG_IsOK(ecode3)) {
20716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20717 }
20718 arg3 = static_cast< double >(val3);
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20722 wxPyEndAllowThreads(__tstate);
20723 if (PyErr_Occurred()) SWIG_fail;
20724 }
20725 {
20726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20727 }
20728 {
20729 if (temp2)
20730 delete arg2;
20731 }
20732 return resultobj;
20733 fail:
20734 {
20735 if (temp2)
20736 delete arg2;
20737 }
20738 return NULL;
20739 }
20740
20741
20742 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20743 PyObject *resultobj = 0;
20744 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20745 wxString *arg2 = 0 ;
20746 bool arg3 ;
20747 bool result;
20748 void *argp1 = 0 ;
20749 int res1 = 0 ;
20750 bool temp2 = false ;
20751 bool val3 ;
20752 int ecode3 = 0 ;
20753 PyObject * obj0 = 0 ;
20754 PyObject * obj1 = 0 ;
20755 PyObject * obj2 = 0 ;
20756 char * kwnames[] = {
20757 (char *) "self",(char *) "key",(char *) "value", NULL
20758 };
20759
20760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20762 if (!SWIG_IsOK(res1)) {
20763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20764 }
20765 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20766 {
20767 arg2 = wxString_in_helper(obj1);
20768 if (arg2 == NULL) SWIG_fail;
20769 temp2 = true;
20770 }
20771 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20772 if (!SWIG_IsOK(ecode3)) {
20773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20774 }
20775 arg3 = static_cast< bool >(val3);
20776 {
20777 PyThreadState* __tstate = wxPyBeginAllowThreads();
20778 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 {
20783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20784 }
20785 {
20786 if (temp2)
20787 delete arg2;
20788 }
20789 return resultobj;
20790 fail:
20791 {
20792 if (temp2)
20793 delete arg2;
20794 }
20795 return NULL;
20796 }
20797
20798
20799 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20800 PyObject *resultobj = 0;
20801 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20802 bool arg2 = (bool) false ;
20803 bool result;
20804 void *argp1 = 0 ;
20805 int res1 = 0 ;
20806 bool val2 ;
20807 int ecode2 = 0 ;
20808 PyObject * obj0 = 0 ;
20809 PyObject * obj1 = 0 ;
20810 char * kwnames[] = {
20811 (char *) "self",(char *) "currentOnly", NULL
20812 };
20813
20814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20816 if (!SWIG_IsOK(res1)) {
20817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20818 }
20819 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20820 if (obj1) {
20821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20822 if (!SWIG_IsOK(ecode2)) {
20823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20824 }
20825 arg2 = static_cast< bool >(val2);
20826 }
20827 {
20828 PyThreadState* __tstate = wxPyBeginAllowThreads();
20829 result = (bool)(arg1)->Flush(arg2);
20830 wxPyEndAllowThreads(__tstate);
20831 if (PyErr_Occurred()) SWIG_fail;
20832 }
20833 {
20834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20835 }
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20843 PyObject *resultobj = 0;
20844 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20845 wxString *arg2 = 0 ;
20846 wxString *arg3 = 0 ;
20847 bool result;
20848 void *argp1 = 0 ;
20849 int res1 = 0 ;
20850 bool temp2 = false ;
20851 bool temp3 = false ;
20852 PyObject * obj0 = 0 ;
20853 PyObject * obj1 = 0 ;
20854 PyObject * obj2 = 0 ;
20855 char * kwnames[] = {
20856 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20857 };
20858
20859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20861 if (!SWIG_IsOK(res1)) {
20862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20863 }
20864 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20865 {
20866 arg2 = wxString_in_helper(obj1);
20867 if (arg2 == NULL) SWIG_fail;
20868 temp2 = true;
20869 }
20870 {
20871 arg3 = wxString_in_helper(obj2);
20872 if (arg3 == NULL) SWIG_fail;
20873 temp3 = true;
20874 }
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 {
20882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20883 }
20884 {
20885 if (temp2)
20886 delete arg2;
20887 }
20888 {
20889 if (temp3)
20890 delete arg3;
20891 }
20892 return resultobj;
20893 fail:
20894 {
20895 if (temp2)
20896 delete arg2;
20897 }
20898 {
20899 if (temp3)
20900 delete arg3;
20901 }
20902 return NULL;
20903 }
20904
20905
20906 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20907 PyObject *resultobj = 0;
20908 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20909 wxString *arg2 = 0 ;
20910 wxString *arg3 = 0 ;
20911 bool result;
20912 void *argp1 = 0 ;
20913 int res1 = 0 ;
20914 bool temp2 = false ;
20915 bool temp3 = false ;
20916 PyObject * obj0 = 0 ;
20917 PyObject * obj1 = 0 ;
20918 PyObject * obj2 = 0 ;
20919 char * kwnames[] = {
20920 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20921 };
20922
20923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20927 }
20928 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20929 {
20930 arg2 = wxString_in_helper(obj1);
20931 if (arg2 == NULL) SWIG_fail;
20932 temp2 = true;
20933 }
20934 {
20935 arg3 = wxString_in_helper(obj2);
20936 if (arg3 == NULL) SWIG_fail;
20937 temp3 = true;
20938 }
20939 {
20940 PyThreadState* __tstate = wxPyBeginAllowThreads();
20941 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20942 wxPyEndAllowThreads(__tstate);
20943 if (PyErr_Occurred()) SWIG_fail;
20944 }
20945 {
20946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20947 }
20948 {
20949 if (temp2)
20950 delete arg2;
20951 }
20952 {
20953 if (temp3)
20954 delete arg3;
20955 }
20956 return resultobj;
20957 fail:
20958 {
20959 if (temp2)
20960 delete arg2;
20961 }
20962 {
20963 if (temp3)
20964 delete arg3;
20965 }
20966 return NULL;
20967 }
20968
20969
20970 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20971 PyObject *resultobj = 0;
20972 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20973 wxString *arg2 = 0 ;
20974 bool arg3 = (bool) true ;
20975 bool result;
20976 void *argp1 = 0 ;
20977 int res1 = 0 ;
20978 bool temp2 = false ;
20979 bool val3 ;
20980 int ecode3 = 0 ;
20981 PyObject * obj0 = 0 ;
20982 PyObject * obj1 = 0 ;
20983 PyObject * obj2 = 0 ;
20984 char * kwnames[] = {
20985 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20986 };
20987
20988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20990 if (!SWIG_IsOK(res1)) {
20991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20992 }
20993 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20994 {
20995 arg2 = wxString_in_helper(obj1);
20996 if (arg2 == NULL) SWIG_fail;
20997 temp2 = true;
20998 }
20999 if (obj2) {
21000 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21001 if (!SWIG_IsOK(ecode3)) {
21002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
21003 }
21004 arg3 = static_cast< bool >(val3);
21005 }
21006 {
21007 PyThreadState* __tstate = wxPyBeginAllowThreads();
21008 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
21009 wxPyEndAllowThreads(__tstate);
21010 if (PyErr_Occurred()) SWIG_fail;
21011 }
21012 {
21013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21014 }
21015 {
21016 if (temp2)
21017 delete arg2;
21018 }
21019 return resultobj;
21020 fail:
21021 {
21022 if (temp2)
21023 delete arg2;
21024 }
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj = 0;
21031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21032 wxString *arg2 = 0 ;
21033 bool result;
21034 void *argp1 = 0 ;
21035 int res1 = 0 ;
21036 bool temp2 = false ;
21037 PyObject * obj0 = 0 ;
21038 PyObject * obj1 = 0 ;
21039 char * kwnames[] = {
21040 (char *) "self",(char *) "key", NULL
21041 };
21042
21043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
21044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21045 if (!SWIG_IsOK(res1)) {
21046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21047 }
21048 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21049 {
21050 arg2 = wxString_in_helper(obj1);
21051 if (arg2 == NULL) SWIG_fail;
21052 temp2 = true;
21053 }
21054 {
21055 PyThreadState* __tstate = wxPyBeginAllowThreads();
21056 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
21057 wxPyEndAllowThreads(__tstate);
21058 if (PyErr_Occurred()) SWIG_fail;
21059 }
21060 {
21061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21062 }
21063 {
21064 if (temp2)
21065 delete arg2;
21066 }
21067 return resultobj;
21068 fail:
21069 {
21070 if (temp2)
21071 delete arg2;
21072 }
21073 return NULL;
21074 }
21075
21076
21077 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21078 PyObject *resultobj = 0;
21079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21080 bool result;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 PyObject *swig_obj[1] ;
21084
21085 if (!args) SWIG_fail;
21086 swig_obj[0] = args;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21090 }
21091 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21092 {
21093 PyThreadState* __tstate = wxPyBeginAllowThreads();
21094 result = (bool)(arg1)->DeleteAll();
21095 wxPyEndAllowThreads(__tstate);
21096 if (PyErr_Occurred()) SWIG_fail;
21097 }
21098 {
21099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21100 }
21101 return resultobj;
21102 fail:
21103 return NULL;
21104 }
21105
21106
21107 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21108 PyObject *resultobj = 0;
21109 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21110 bool arg2 = (bool) true ;
21111 void *argp1 = 0 ;
21112 int res1 = 0 ;
21113 bool val2 ;
21114 int ecode2 = 0 ;
21115 PyObject * obj0 = 0 ;
21116 PyObject * obj1 = 0 ;
21117 char * kwnames[] = {
21118 (char *) "self",(char *) "doIt", NULL
21119 };
21120
21121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21125 }
21126 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21127 if (obj1) {
21128 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21129 if (!SWIG_IsOK(ecode2)) {
21130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
21131 }
21132 arg2 = static_cast< bool >(val2);
21133 }
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 (arg1)->SetExpandEnvVars(arg2);
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = SWIG_Py_Void();
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148 PyObject *resultobj = 0;
21149 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21150 bool result;
21151 void *argp1 = 0 ;
21152 int res1 = 0 ;
21153 PyObject *swig_obj[1] ;
21154
21155 if (!args) SWIG_fail;
21156 swig_obj[0] = args;
21157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21160 }
21161 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 {
21169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21170 }
21171 return resultobj;
21172 fail:
21173 return NULL;
21174 }
21175
21176
21177 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21178 PyObject *resultobj = 0;
21179 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21180 bool arg2 = (bool) true ;
21181 void *argp1 = 0 ;
21182 int res1 = 0 ;
21183 bool val2 ;
21184 int ecode2 = 0 ;
21185 PyObject * obj0 = 0 ;
21186 PyObject * obj1 = 0 ;
21187 char * kwnames[] = {
21188 (char *) "self",(char *) "doIt", NULL
21189 };
21190
21191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
21192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21193 if (!SWIG_IsOK(res1)) {
21194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21195 }
21196 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21197 if (obj1) {
21198 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21199 if (!SWIG_IsOK(ecode2)) {
21200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
21201 }
21202 arg2 = static_cast< bool >(val2);
21203 }
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 (arg1)->SetRecordDefaults(arg2);
21207 wxPyEndAllowThreads(__tstate);
21208 if (PyErr_Occurred()) SWIG_fail;
21209 }
21210 resultobj = SWIG_Py_Void();
21211 return resultobj;
21212 fail:
21213 return NULL;
21214 }
21215
21216
21217 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21218 PyObject *resultobj = 0;
21219 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21220 bool result;
21221 void *argp1 = 0 ;
21222 int res1 = 0 ;
21223 PyObject *swig_obj[1] ;
21224
21225 if (!args) SWIG_fail;
21226 swig_obj[0] = args;
21227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21228 if (!SWIG_IsOK(res1)) {
21229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21230 }
21231 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 {
21239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21240 }
21241 return resultobj;
21242 fail:
21243 return NULL;
21244 }
21245
21246
21247 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21248 PyObject *resultobj = 0;
21249 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21250 wxString *arg2 = 0 ;
21251 wxString result;
21252 void *argp1 = 0 ;
21253 int res1 = 0 ;
21254 bool temp2 = false ;
21255 PyObject * obj0 = 0 ;
21256 PyObject * obj1 = 0 ;
21257 char * kwnames[] = {
21258 (char *) "self",(char *) "str", NULL
21259 };
21260
21261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21263 if (!SWIG_IsOK(res1)) {
21264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21265 }
21266 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21267 {
21268 arg2 = wxString_in_helper(obj1);
21269 if (arg2 == NULL) SWIG_fail;
21270 temp2 = true;
21271 }
21272 {
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21275 wxPyEndAllowThreads(__tstate);
21276 if (PyErr_Occurred()) SWIG_fail;
21277 }
21278 {
21279 #if wxUSE_UNICODE
21280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21281 #else
21282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21283 #endif
21284 }
21285 {
21286 if (temp2)
21287 delete arg2;
21288 }
21289 return resultobj;
21290 fail:
21291 {
21292 if (temp2)
21293 delete arg2;
21294 }
21295 return NULL;
21296 }
21297
21298
21299 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21300 PyObject *resultobj = 0;
21301 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21302 wxString result;
21303 void *argp1 = 0 ;
21304 int res1 = 0 ;
21305 PyObject *swig_obj[1] ;
21306
21307 if (!args) SWIG_fail;
21308 swig_obj[0] = args;
21309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21310 if (!SWIG_IsOK(res1)) {
21311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21312 }
21313 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21314 {
21315 PyThreadState* __tstate = wxPyBeginAllowThreads();
21316 result = ((wxConfigBase const *)arg1)->GetAppName();
21317 wxPyEndAllowThreads(__tstate);
21318 if (PyErr_Occurred()) SWIG_fail;
21319 }
21320 {
21321 #if wxUSE_UNICODE
21322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21323 #else
21324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21325 #endif
21326 }
21327 return resultobj;
21328 fail:
21329 return NULL;
21330 }
21331
21332
21333 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21334 PyObject *resultobj = 0;
21335 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21336 wxString result;
21337 void *argp1 = 0 ;
21338 int res1 = 0 ;
21339 PyObject *swig_obj[1] ;
21340
21341 if (!args) SWIG_fail;
21342 swig_obj[0] = args;
21343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21344 if (!SWIG_IsOK(res1)) {
21345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21346 }
21347 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21348 {
21349 PyThreadState* __tstate = wxPyBeginAllowThreads();
21350 result = ((wxConfigBase const *)arg1)->GetVendorName();
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 {
21355 #if wxUSE_UNICODE
21356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21357 #else
21358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21359 #endif
21360 }
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21368 PyObject *resultobj = 0;
21369 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21370 wxString *arg2 = 0 ;
21371 void *argp1 = 0 ;
21372 int res1 = 0 ;
21373 bool temp2 = false ;
21374 PyObject * obj0 = 0 ;
21375 PyObject * obj1 = 0 ;
21376 char * kwnames[] = {
21377 (char *) "self",(char *) "appName", NULL
21378 };
21379
21380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21382 if (!SWIG_IsOK(res1)) {
21383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21384 }
21385 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21386 {
21387 arg2 = wxString_in_helper(obj1);
21388 if (arg2 == NULL) SWIG_fail;
21389 temp2 = true;
21390 }
21391 {
21392 PyThreadState* __tstate = wxPyBeginAllowThreads();
21393 (arg1)->SetAppName((wxString const &)*arg2);
21394 wxPyEndAllowThreads(__tstate);
21395 if (PyErr_Occurred()) SWIG_fail;
21396 }
21397 resultobj = SWIG_Py_Void();
21398 {
21399 if (temp2)
21400 delete arg2;
21401 }
21402 return resultobj;
21403 fail:
21404 {
21405 if (temp2)
21406 delete arg2;
21407 }
21408 return NULL;
21409 }
21410
21411
21412 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21413 PyObject *resultobj = 0;
21414 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21415 wxString *arg2 = 0 ;
21416 void *argp1 = 0 ;
21417 int res1 = 0 ;
21418 bool temp2 = false ;
21419 PyObject * obj0 = 0 ;
21420 PyObject * obj1 = 0 ;
21421 char * kwnames[] = {
21422 (char *) "self",(char *) "vendorName", NULL
21423 };
21424
21425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21427 if (!SWIG_IsOK(res1)) {
21428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21429 }
21430 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21431 {
21432 arg2 = wxString_in_helper(obj1);
21433 if (arg2 == NULL) SWIG_fail;
21434 temp2 = true;
21435 }
21436 {
21437 PyThreadState* __tstate = wxPyBeginAllowThreads();
21438 (arg1)->SetVendorName((wxString const &)*arg2);
21439 wxPyEndAllowThreads(__tstate);
21440 if (PyErr_Occurred()) SWIG_fail;
21441 }
21442 resultobj = SWIG_Py_Void();
21443 {
21444 if (temp2)
21445 delete arg2;
21446 }
21447 return resultobj;
21448 fail:
21449 {
21450 if (temp2)
21451 delete arg2;
21452 }
21453 return NULL;
21454 }
21455
21456
21457 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21458 PyObject *resultobj = 0;
21459 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21460 long arg2 ;
21461 void *argp1 = 0 ;
21462 int res1 = 0 ;
21463 long val2 ;
21464 int ecode2 = 0 ;
21465 PyObject * obj0 = 0 ;
21466 PyObject * obj1 = 0 ;
21467 char * kwnames[] = {
21468 (char *) "self",(char *) "style", NULL
21469 };
21470
21471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21473 if (!SWIG_IsOK(res1)) {
21474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21475 }
21476 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21477 ecode2 = SWIG_AsVal_long(obj1, &val2);
21478 if (!SWIG_IsOK(ecode2)) {
21479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21480 }
21481 arg2 = static_cast< long >(val2);
21482 {
21483 PyThreadState* __tstate = wxPyBeginAllowThreads();
21484 (arg1)->SetStyle(arg2);
21485 wxPyEndAllowThreads(__tstate);
21486 if (PyErr_Occurred()) SWIG_fail;
21487 }
21488 resultobj = SWIG_Py_Void();
21489 return resultobj;
21490 fail:
21491 return NULL;
21492 }
21493
21494
21495 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21496 PyObject *resultobj = 0;
21497 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21498 long result;
21499 void *argp1 = 0 ;
21500 int res1 = 0 ;
21501 PyObject *swig_obj[1] ;
21502
21503 if (!args) SWIG_fail;
21504 swig_obj[0] = args;
21505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21506 if (!SWIG_IsOK(res1)) {
21507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21508 }
21509 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21510 {
21511 PyThreadState* __tstate = wxPyBeginAllowThreads();
21512 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21513 wxPyEndAllowThreads(__tstate);
21514 if (PyErr_Occurred()) SWIG_fail;
21515 }
21516 resultobj = SWIG_From_long(static_cast< long >(result));
21517 return resultobj;
21518 fail:
21519 return NULL;
21520 }
21521
21522
21523 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21524 PyObject *obj;
21525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21526 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21527 return SWIG_Py_Void();
21528 }
21529
21530 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj = 0;
21532 wxString const &arg1_defvalue = wxPyEmptyString ;
21533 wxString *arg1 = (wxString *) &arg1_defvalue ;
21534 wxString const &arg2_defvalue = wxPyEmptyString ;
21535 wxString *arg2 = (wxString *) &arg2_defvalue ;
21536 wxString const &arg3_defvalue = wxPyEmptyString ;
21537 wxString *arg3 = (wxString *) &arg3_defvalue ;
21538 wxString const &arg4_defvalue = wxPyEmptyString ;
21539 wxString *arg4 = (wxString *) &arg4_defvalue ;
21540 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21541 wxConfig *result = 0 ;
21542 bool temp1 = false ;
21543 bool temp2 = false ;
21544 bool temp3 = false ;
21545 bool temp4 = false ;
21546 long val5 ;
21547 int ecode5 = 0 ;
21548 PyObject * obj0 = 0 ;
21549 PyObject * obj1 = 0 ;
21550 PyObject * obj2 = 0 ;
21551 PyObject * obj3 = 0 ;
21552 PyObject * obj4 = 0 ;
21553 char * kwnames[] = {
21554 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21555 };
21556
21557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21558 if (obj0) {
21559 {
21560 arg1 = wxString_in_helper(obj0);
21561 if (arg1 == NULL) SWIG_fail;
21562 temp1 = true;
21563 }
21564 }
21565 if (obj1) {
21566 {
21567 arg2 = wxString_in_helper(obj1);
21568 if (arg2 == NULL) SWIG_fail;
21569 temp2 = true;
21570 }
21571 }
21572 if (obj2) {
21573 {
21574 arg3 = wxString_in_helper(obj2);
21575 if (arg3 == NULL) SWIG_fail;
21576 temp3 = true;
21577 }
21578 }
21579 if (obj3) {
21580 {
21581 arg4 = wxString_in_helper(obj3);
21582 if (arg4 == NULL) SWIG_fail;
21583 temp4 = true;
21584 }
21585 }
21586 if (obj4) {
21587 ecode5 = SWIG_AsVal_long(obj4, &val5);
21588 if (!SWIG_IsOK(ecode5)) {
21589 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21590 }
21591 arg5 = static_cast< long >(val5);
21592 }
21593 {
21594 PyThreadState* __tstate = wxPyBeginAllowThreads();
21595 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21600 {
21601 if (temp1)
21602 delete arg1;
21603 }
21604 {
21605 if (temp2)
21606 delete arg2;
21607 }
21608 {
21609 if (temp3)
21610 delete arg3;
21611 }
21612 {
21613 if (temp4)
21614 delete arg4;
21615 }
21616 return resultobj;
21617 fail:
21618 {
21619 if (temp1)
21620 delete arg1;
21621 }
21622 {
21623 if (temp2)
21624 delete arg2;
21625 }
21626 {
21627 if (temp3)
21628 delete arg3;
21629 }
21630 {
21631 if (temp4)
21632 delete arg4;
21633 }
21634 return NULL;
21635 }
21636
21637
21638 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21639 PyObject *resultobj = 0;
21640 wxConfig *arg1 = (wxConfig *) 0 ;
21641 void *argp1 = 0 ;
21642 int res1 = 0 ;
21643 PyObject *swig_obj[1] ;
21644
21645 if (!args) SWIG_fail;
21646 swig_obj[0] = args;
21647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21648 if (!SWIG_IsOK(res1)) {
21649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21650 }
21651 arg1 = reinterpret_cast< wxConfig * >(argp1);
21652 {
21653 PyThreadState* __tstate = wxPyBeginAllowThreads();
21654 delete arg1;
21655
21656 wxPyEndAllowThreads(__tstate);
21657 if (PyErr_Occurred()) SWIG_fail;
21658 }
21659 resultobj = SWIG_Py_Void();
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 PyObject *obj;
21668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21669 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21670 return SWIG_Py_Void();
21671 }
21672
21673 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 return SWIG_Python_InitShadowInstance(args);
21675 }
21676
21677 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21678 PyObject *resultobj = 0;
21679 wxString const &arg1_defvalue = wxPyEmptyString ;
21680 wxString *arg1 = (wxString *) &arg1_defvalue ;
21681 wxString const &arg2_defvalue = wxPyEmptyString ;
21682 wxString *arg2 = (wxString *) &arg2_defvalue ;
21683 wxString const &arg3_defvalue = wxPyEmptyString ;
21684 wxString *arg3 = (wxString *) &arg3_defvalue ;
21685 wxString const &arg4_defvalue = wxPyEmptyString ;
21686 wxString *arg4 = (wxString *) &arg4_defvalue ;
21687 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21688 wxFileConfig *result = 0 ;
21689 bool temp1 = false ;
21690 bool temp2 = false ;
21691 bool temp3 = false ;
21692 bool temp4 = false ;
21693 long val5 ;
21694 int ecode5 = 0 ;
21695 PyObject * obj0 = 0 ;
21696 PyObject * obj1 = 0 ;
21697 PyObject * obj2 = 0 ;
21698 PyObject * obj3 = 0 ;
21699 PyObject * obj4 = 0 ;
21700 char * kwnames[] = {
21701 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21702 };
21703
21704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21705 if (obj0) {
21706 {
21707 arg1 = wxString_in_helper(obj0);
21708 if (arg1 == NULL) SWIG_fail;
21709 temp1 = true;
21710 }
21711 }
21712 if (obj1) {
21713 {
21714 arg2 = wxString_in_helper(obj1);
21715 if (arg2 == NULL) SWIG_fail;
21716 temp2 = true;
21717 }
21718 }
21719 if (obj2) {
21720 {
21721 arg3 = wxString_in_helper(obj2);
21722 if (arg3 == NULL) SWIG_fail;
21723 temp3 = true;
21724 }
21725 }
21726 if (obj3) {
21727 {
21728 arg4 = wxString_in_helper(obj3);
21729 if (arg4 == NULL) SWIG_fail;
21730 temp4 = true;
21731 }
21732 }
21733 if (obj4) {
21734 ecode5 = SWIG_AsVal_long(obj4, &val5);
21735 if (!SWIG_IsOK(ecode5)) {
21736 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21737 }
21738 arg5 = static_cast< long >(val5);
21739 }
21740 {
21741 PyThreadState* __tstate = wxPyBeginAllowThreads();
21742 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21743 wxPyEndAllowThreads(__tstate);
21744 if (PyErr_Occurred()) SWIG_fail;
21745 }
21746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21747 {
21748 if (temp1)
21749 delete arg1;
21750 }
21751 {
21752 if (temp2)
21753 delete arg2;
21754 }
21755 {
21756 if (temp3)
21757 delete arg3;
21758 }
21759 {
21760 if (temp4)
21761 delete arg4;
21762 }
21763 return resultobj;
21764 fail:
21765 {
21766 if (temp1)
21767 delete arg1;
21768 }
21769 {
21770 if (temp2)
21771 delete arg2;
21772 }
21773 {
21774 if (temp3)
21775 delete arg3;
21776 }
21777 {
21778 if (temp4)
21779 delete arg4;
21780 }
21781 return NULL;
21782 }
21783
21784
21785 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21786 PyObject *resultobj = 0;
21787 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21788 void *argp1 = 0 ;
21789 int res1 = 0 ;
21790 PyObject *swig_obj[1] ;
21791
21792 if (!args) SWIG_fail;
21793 swig_obj[0] = args;
21794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21795 if (!SWIG_IsOK(res1)) {
21796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21797 }
21798 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 delete arg1;
21802
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 resultobj = SWIG_Py_Void();
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21814 PyObject *obj;
21815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21816 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21817 return SWIG_Py_Void();
21818 }
21819
21820 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21821 return SWIG_Python_InitShadowInstance(args);
21822 }
21823
21824 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21825 PyObject *resultobj = 0;
21826 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21827 wxString *arg2 = 0 ;
21828 wxConfigPathChanger *result = 0 ;
21829 void *argp1 = 0 ;
21830 int res1 = 0 ;
21831 bool temp2 = false ;
21832 PyObject * obj0 = 0 ;
21833 PyObject * obj1 = 0 ;
21834 char * kwnames[] = {
21835 (char *) "config",(char *) "entry", NULL
21836 };
21837
21838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21840 if (!SWIG_IsOK(res1)) {
21841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21842 }
21843 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21844 {
21845 arg2 = wxString_in_helper(obj1);
21846 if (arg2 == NULL) SWIG_fail;
21847 temp2 = true;
21848 }
21849 {
21850 PyThreadState* __tstate = wxPyBeginAllowThreads();
21851 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21852 wxPyEndAllowThreads(__tstate);
21853 if (PyErr_Occurred()) SWIG_fail;
21854 }
21855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21856 {
21857 if (temp2)
21858 delete arg2;
21859 }
21860 return resultobj;
21861 fail:
21862 {
21863 if (temp2)
21864 delete arg2;
21865 }
21866 return NULL;
21867 }
21868
21869
21870 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21871 PyObject *resultobj = 0;
21872 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21873 void *argp1 = 0 ;
21874 int res1 = 0 ;
21875 PyObject *swig_obj[1] ;
21876
21877 if (!args) SWIG_fail;
21878 swig_obj[0] = args;
21879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21880 if (!SWIG_IsOK(res1)) {
21881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21882 }
21883 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21884 {
21885 PyThreadState* __tstate = wxPyBeginAllowThreads();
21886 delete arg1;
21887
21888 wxPyEndAllowThreads(__tstate);
21889 if (PyErr_Occurred()) SWIG_fail;
21890 }
21891 resultobj = SWIG_Py_Void();
21892 return resultobj;
21893 fail:
21894 return NULL;
21895 }
21896
21897
21898 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21899 PyObject *resultobj = 0;
21900 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21901 wxString *result = 0 ;
21902 void *argp1 = 0 ;
21903 int res1 = 0 ;
21904 PyObject *swig_obj[1] ;
21905
21906 if (!args) SWIG_fail;
21907 swig_obj[0] = args;
21908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21909 if (!SWIG_IsOK(res1)) {
21910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21911 }
21912 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 {
21916 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21917 result = (wxString *) &_result_ref;
21918 }
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 {
21923 #if wxUSE_UNICODE
21924 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21925 #else
21926 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21927 #endif
21928 }
21929 return resultobj;
21930 fail:
21931 return NULL;
21932 }
21933
21934
21935 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21936 PyObject *obj;
21937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21938 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21939 return SWIG_Py_Void();
21940 }
21941
21942 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21943 return SWIG_Python_InitShadowInstance(args);
21944 }
21945
21946 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21947 PyObject *resultobj = 0;
21948 wxString *arg1 = 0 ;
21949 wxString result;
21950 bool temp1 = false ;
21951 PyObject * obj0 = 0 ;
21952 char * kwnames[] = {
21953 (char *) "sz", NULL
21954 };
21955
21956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21957 {
21958 arg1 = wxString_in_helper(obj0);
21959 if (arg1 == NULL) SWIG_fail;
21960 temp1 = true;
21961 }
21962 {
21963 PyThreadState* __tstate = wxPyBeginAllowThreads();
21964 result = wxExpandEnvVars((wxString const &)*arg1);
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 {
21969 #if wxUSE_UNICODE
21970 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21971 #else
21972 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21973 #endif
21974 }
21975 {
21976 if (temp1)
21977 delete arg1;
21978 }
21979 return resultobj;
21980 fail:
21981 {
21982 if (temp1)
21983 delete arg1;
21984 }
21985 return NULL;
21986 }
21987
21988
21989 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21990 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21991 return 1;
21992 }
21993
21994
21995 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21996 PyObject *pyobj = 0;
21997
21998 {
21999 #if wxUSE_UNICODE
22000 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22001 #else
22002 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
22003 #endif
22004 }
22005 return pyobj;
22006 }
22007
22008
22009 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
22010 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
22011 return 1;
22012 }
22013
22014
22015 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
22016 PyObject *pyobj = 0;
22017
22018 {
22019 #if wxUSE_UNICODE
22020 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22021 #else
22022 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
22023 #endif
22024 }
22025 return pyobj;
22026 }
22027
22028
22029 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22030 PyObject *resultobj = 0;
22031 wxDateTime::Country arg1 ;
22032 int val1 ;
22033 int ecode1 = 0 ;
22034 PyObject * obj0 = 0 ;
22035 char * kwnames[] = {
22036 (char *) "country", NULL
22037 };
22038
22039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
22040 ecode1 = SWIG_AsVal_int(obj0, &val1);
22041 if (!SWIG_IsOK(ecode1)) {
22042 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22043 }
22044 arg1 = static_cast< wxDateTime::Country >(val1);
22045 {
22046 PyThreadState* __tstate = wxPyBeginAllowThreads();
22047 wxDateTime::SetCountry(arg1);
22048 wxPyEndAllowThreads(__tstate);
22049 if (PyErr_Occurred()) SWIG_fail;
22050 }
22051 resultobj = SWIG_Py_Void();
22052 return resultobj;
22053 fail:
22054 return NULL;
22055 }
22056
22057
22058 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22059 PyObject *resultobj = 0;
22060 wxDateTime::Country result;
22061
22062 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
22063 {
22064 PyThreadState* __tstate = wxPyBeginAllowThreads();
22065 result = (wxDateTime::Country)wxDateTime::GetCountry();
22066 wxPyEndAllowThreads(__tstate);
22067 if (PyErr_Occurred()) SWIG_fail;
22068 }
22069 resultobj = SWIG_From_int(static_cast< int >(result));
22070 return resultobj;
22071 fail:
22072 return NULL;
22073 }
22074
22075
22076 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22077 PyObject *resultobj = 0;
22078 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
22079 bool result;
22080 int val1 ;
22081 int ecode1 = 0 ;
22082 PyObject * obj0 = 0 ;
22083 char * kwnames[] = {
22084 (char *) "country", NULL
22085 };
22086
22087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
22088 if (obj0) {
22089 ecode1 = SWIG_AsVal_int(obj0, &val1);
22090 if (!SWIG_IsOK(ecode1)) {
22091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
22092 }
22093 arg1 = static_cast< wxDateTime::Country >(val1);
22094 }
22095 {
22096 PyThreadState* __tstate = wxPyBeginAllowThreads();
22097 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
22098 wxPyEndAllowThreads(__tstate);
22099 if (PyErr_Occurred()) SWIG_fail;
22100 }
22101 {
22102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22103 }
22104 return resultobj;
22105 fail:
22106 return NULL;
22107 }
22108
22109
22110 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22111 PyObject *resultobj = 0;
22112 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22113 int result;
22114 int val1 ;
22115 int ecode1 = 0 ;
22116 PyObject * obj0 = 0 ;
22117 char * kwnames[] = {
22118 (char *) "cal", NULL
22119 };
22120
22121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
22122 if (obj0) {
22123 ecode1 = SWIG_AsVal_int(obj0, &val1);
22124 if (!SWIG_IsOK(ecode1)) {
22125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22126 }
22127 arg1 = static_cast< wxDateTime::Calendar >(val1);
22128 }
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (int)wxDateTime::GetCurrentYear(arg1);
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 resultobj = SWIG_From_int(static_cast< int >(result));
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22143 PyObject *resultobj = 0;
22144 int arg1 ;
22145 int result;
22146 int val1 ;
22147 int ecode1 = 0 ;
22148 PyObject * obj0 = 0 ;
22149 char * kwnames[] = {
22150 (char *) "year", NULL
22151 };
22152
22153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
22154 ecode1 = SWIG_AsVal_int(obj0, &val1);
22155 if (!SWIG_IsOK(ecode1)) {
22156 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
22157 }
22158 arg1 = static_cast< int >(val1);
22159 {
22160 PyThreadState* __tstate = wxPyBeginAllowThreads();
22161 result = (int)wxDateTime::ConvertYearToBC(arg1);
22162 wxPyEndAllowThreads(__tstate);
22163 if (PyErr_Occurred()) SWIG_fail;
22164 }
22165 resultobj = SWIG_From_int(static_cast< int >(result));
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22173 PyObject *resultobj = 0;
22174 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22175 wxDateTime::Month result;
22176 int val1 ;
22177 int ecode1 = 0 ;
22178 PyObject * obj0 = 0 ;
22179 char * kwnames[] = {
22180 (char *) "cal", NULL
22181 };
22182
22183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
22184 if (obj0) {
22185 ecode1 = SWIG_AsVal_int(obj0, &val1);
22186 if (!SWIG_IsOK(ecode1)) {
22187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
22188 }
22189 arg1 = static_cast< wxDateTime::Calendar >(val1);
22190 }
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 resultobj = SWIG_From_int(static_cast< int >(result));
22198 return resultobj;
22199 fail:
22200 return NULL;
22201 }
22202
22203
22204 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22205 PyObject *resultobj = 0;
22206 int arg1 = (int) wxDateTime::Inv_Year ;
22207 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22208 bool result;
22209 int val1 ;
22210 int ecode1 = 0 ;
22211 int val2 ;
22212 int ecode2 = 0 ;
22213 PyObject * obj0 = 0 ;
22214 PyObject * obj1 = 0 ;
22215 char * kwnames[] = {
22216 (char *) "year",(char *) "cal", NULL
22217 };
22218
22219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22220 if (obj0) {
22221 ecode1 = SWIG_AsVal_int(obj0, &val1);
22222 if (!SWIG_IsOK(ecode1)) {
22223 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22224 }
22225 arg1 = static_cast< int >(val1);
22226 }
22227 if (obj1) {
22228 ecode2 = SWIG_AsVal_int(obj1, &val2);
22229 if (!SWIG_IsOK(ecode2)) {
22230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22231 }
22232 arg2 = static_cast< wxDateTime::Calendar >(val2);
22233 }
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 {
22241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22242 }
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22250 PyObject *resultobj = 0;
22251 int arg1 = (int) wxDateTime::Inv_Year ;
22252 int result;
22253 int val1 ;
22254 int ecode1 = 0 ;
22255 PyObject * obj0 = 0 ;
22256 char * kwnames[] = {
22257 (char *) "year", NULL
22258 };
22259
22260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22261 if (obj0) {
22262 ecode1 = SWIG_AsVal_int(obj0, &val1);
22263 if (!SWIG_IsOK(ecode1)) {
22264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22265 }
22266 arg1 = static_cast< int >(val1);
22267 }
22268 {
22269 PyThreadState* __tstate = wxPyBeginAllowThreads();
22270 result = (int)wxDateTime::GetCentury(arg1);
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 resultobj = SWIG_From_int(static_cast< int >(result));
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22282 PyObject *resultobj = 0;
22283 int arg1 ;
22284 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22285 int result;
22286 int val1 ;
22287 int ecode1 = 0 ;
22288 int val2 ;
22289 int ecode2 = 0 ;
22290 PyObject * obj0 = 0 ;
22291 PyObject * obj1 = 0 ;
22292 char * kwnames[] = {
22293 (char *) "year",(char *) "cal", NULL
22294 };
22295
22296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22297 ecode1 = SWIG_AsVal_int(obj0, &val1);
22298 if (!SWIG_IsOK(ecode1)) {
22299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22300 }
22301 arg1 = static_cast< int >(val1);
22302 if (obj1) {
22303 ecode2 = SWIG_AsVal_int(obj1, &val2);
22304 if (!SWIG_IsOK(ecode2)) {
22305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22306 }
22307 arg2 = static_cast< wxDateTime::Calendar >(val2);
22308 }
22309 {
22310 PyThreadState* __tstate = wxPyBeginAllowThreads();
22311 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22312 wxPyEndAllowThreads(__tstate);
22313 if (PyErr_Occurred()) SWIG_fail;
22314 }
22315 resultobj = SWIG_From_int(static_cast< int >(result));
22316 return resultobj;
22317 fail:
22318 return NULL;
22319 }
22320
22321
22322 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22323 PyObject *resultobj = 0;
22324 wxDateTime::Month arg1 ;
22325 int arg2 = (int) wxDateTime::Inv_Year ;
22326 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22327 int result;
22328 int val1 ;
22329 int ecode1 = 0 ;
22330 int val2 ;
22331 int ecode2 = 0 ;
22332 int val3 ;
22333 int ecode3 = 0 ;
22334 PyObject * obj0 = 0 ;
22335 PyObject * obj1 = 0 ;
22336 PyObject * obj2 = 0 ;
22337 char * kwnames[] = {
22338 (char *) "month",(char *) "year",(char *) "cal", NULL
22339 };
22340
22341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22342 ecode1 = SWIG_AsVal_int(obj0, &val1);
22343 if (!SWIG_IsOK(ecode1)) {
22344 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22345 }
22346 arg1 = static_cast< wxDateTime::Month >(val1);
22347 if (obj1) {
22348 ecode2 = SWIG_AsVal_int(obj1, &val2);
22349 if (!SWIG_IsOK(ecode2)) {
22350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22351 }
22352 arg2 = static_cast< int >(val2);
22353 }
22354 if (obj2) {
22355 ecode3 = SWIG_AsVal_int(obj2, &val3);
22356 if (!SWIG_IsOK(ecode3)) {
22357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22358 }
22359 arg3 = static_cast< wxDateTime::Calendar >(val3);
22360 }
22361 {
22362 PyThreadState* __tstate = wxPyBeginAllowThreads();
22363 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22364 wxPyEndAllowThreads(__tstate);
22365 if (PyErr_Occurred()) SWIG_fail;
22366 }
22367 resultobj = SWIG_From_int(static_cast< int >(result));
22368 return resultobj;
22369 fail:
22370 return NULL;
22371 }
22372
22373
22374 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22375 PyObject *resultobj = 0;
22376 wxDateTime::Month arg1 ;
22377 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22378 wxString result;
22379 int val1 ;
22380 int ecode1 = 0 ;
22381 int val2 ;
22382 int ecode2 = 0 ;
22383 PyObject * obj0 = 0 ;
22384 PyObject * obj1 = 0 ;
22385 char * kwnames[] = {
22386 (char *) "month",(char *) "flags", NULL
22387 };
22388
22389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22390 ecode1 = SWIG_AsVal_int(obj0, &val1);
22391 if (!SWIG_IsOK(ecode1)) {
22392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22393 }
22394 arg1 = static_cast< wxDateTime::Month >(val1);
22395 if (obj1) {
22396 ecode2 = SWIG_AsVal_int(obj1, &val2);
22397 if (!SWIG_IsOK(ecode2)) {
22398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22399 }
22400 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22401 }
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 result = wxDateTime::GetMonthName(arg1,arg2);
22405 wxPyEndAllowThreads(__tstate);
22406 if (PyErr_Occurred()) SWIG_fail;
22407 }
22408 {
22409 #if wxUSE_UNICODE
22410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22411 #else
22412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22413 #endif
22414 }
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22422 PyObject *resultobj = 0;
22423 wxDateTime::WeekDay arg1 ;
22424 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22425 wxString result;
22426 int val1 ;
22427 int ecode1 = 0 ;
22428 int val2 ;
22429 int ecode2 = 0 ;
22430 PyObject * obj0 = 0 ;
22431 PyObject * obj1 = 0 ;
22432 char * kwnames[] = {
22433 (char *) "weekday",(char *) "flags", NULL
22434 };
22435
22436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22437 ecode1 = SWIG_AsVal_int(obj0, &val1);
22438 if (!SWIG_IsOK(ecode1)) {
22439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22440 }
22441 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22442 if (obj1) {
22443 ecode2 = SWIG_AsVal_int(obj1, &val2);
22444 if (!SWIG_IsOK(ecode2)) {
22445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22446 }
22447 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22448 }
22449 {
22450 PyThreadState* __tstate = wxPyBeginAllowThreads();
22451 result = wxDateTime::GetWeekDayName(arg1,arg2);
22452 wxPyEndAllowThreads(__tstate);
22453 if (PyErr_Occurred()) SWIG_fail;
22454 }
22455 {
22456 #if wxUSE_UNICODE
22457 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22458 #else
22459 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22460 #endif
22461 }
22462 return resultobj;
22463 fail:
22464 return NULL;
22465 }
22466
22467
22468 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22469 PyObject *resultobj = 0;
22470 PyObject *result = 0 ;
22471
22472 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22473 {
22474 PyThreadState* __tstate = wxPyBeginAllowThreads();
22475 result = (PyObject *)wxDateTime_GetAmPmStrings();
22476 wxPyEndAllowThreads(__tstate);
22477 if (PyErr_Occurred()) SWIG_fail;
22478 }
22479 resultobj = result;
22480 return resultobj;
22481 fail:
22482 return NULL;
22483 }
22484
22485
22486 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22487 PyObject *resultobj = 0;
22488 int arg1 = (int) wxDateTime::Inv_Year ;
22489 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22490 bool result;
22491 int val1 ;
22492 int ecode1 = 0 ;
22493 int val2 ;
22494 int ecode2 = 0 ;
22495 PyObject * obj0 = 0 ;
22496 PyObject * obj1 = 0 ;
22497 char * kwnames[] = {
22498 (char *) "year",(char *) "country", NULL
22499 };
22500
22501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22502 if (obj0) {
22503 ecode1 = SWIG_AsVal_int(obj0, &val1);
22504 if (!SWIG_IsOK(ecode1)) {
22505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22506 }
22507 arg1 = static_cast< int >(val1);
22508 }
22509 if (obj1) {
22510 ecode2 = SWIG_AsVal_int(obj1, &val2);
22511 if (!SWIG_IsOK(ecode2)) {
22512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22513 }
22514 arg2 = static_cast< wxDateTime::Country >(val2);
22515 }
22516 {
22517 PyThreadState* __tstate = wxPyBeginAllowThreads();
22518 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22519 wxPyEndAllowThreads(__tstate);
22520 if (PyErr_Occurred()) SWIG_fail;
22521 }
22522 {
22523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22524 }
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22532 PyObject *resultobj = 0;
22533 int arg1 = (int) wxDateTime::Inv_Year ;
22534 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22535 wxDateTime result;
22536 int val1 ;
22537 int ecode1 = 0 ;
22538 int val2 ;
22539 int ecode2 = 0 ;
22540 PyObject * obj0 = 0 ;
22541 PyObject * obj1 = 0 ;
22542 char * kwnames[] = {
22543 (char *) "year",(char *) "country", NULL
22544 };
22545
22546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22547 if (obj0) {
22548 ecode1 = SWIG_AsVal_int(obj0, &val1);
22549 if (!SWIG_IsOK(ecode1)) {
22550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22551 }
22552 arg1 = static_cast< int >(val1);
22553 }
22554 if (obj1) {
22555 ecode2 = SWIG_AsVal_int(obj1, &val2);
22556 if (!SWIG_IsOK(ecode2)) {
22557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22558 }
22559 arg2 = static_cast< wxDateTime::Country >(val2);
22560 }
22561 {
22562 PyThreadState* __tstate = wxPyBeginAllowThreads();
22563 result = wxDateTime::GetBeginDST(arg1,arg2);
22564 wxPyEndAllowThreads(__tstate);
22565 if (PyErr_Occurred()) SWIG_fail;
22566 }
22567 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22568 return resultobj;
22569 fail:
22570 return NULL;
22571 }
22572
22573
22574 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22575 PyObject *resultobj = 0;
22576 int arg1 = (int) wxDateTime::Inv_Year ;
22577 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22578 wxDateTime result;
22579 int val1 ;
22580 int ecode1 = 0 ;
22581 int val2 ;
22582 int ecode2 = 0 ;
22583 PyObject * obj0 = 0 ;
22584 PyObject * obj1 = 0 ;
22585 char * kwnames[] = {
22586 (char *) "year",(char *) "country", NULL
22587 };
22588
22589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22590 if (obj0) {
22591 ecode1 = SWIG_AsVal_int(obj0, &val1);
22592 if (!SWIG_IsOK(ecode1)) {
22593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22594 }
22595 arg1 = static_cast< int >(val1);
22596 }
22597 if (obj1) {
22598 ecode2 = SWIG_AsVal_int(obj1, &val2);
22599 if (!SWIG_IsOK(ecode2)) {
22600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22601 }
22602 arg2 = static_cast< wxDateTime::Country >(val2);
22603 }
22604 {
22605 PyThreadState* __tstate = wxPyBeginAllowThreads();
22606 result = wxDateTime::GetEndDST(arg1,arg2);
22607 wxPyEndAllowThreads(__tstate);
22608 if (PyErr_Occurred()) SWIG_fail;
22609 }
22610 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22611 return resultobj;
22612 fail:
22613 return NULL;
22614 }
22615
22616
22617 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22618 PyObject *resultobj = 0;
22619 wxDateTime result;
22620
22621 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22622 {
22623 PyThreadState* __tstate = wxPyBeginAllowThreads();
22624 result = wxDateTime::Now();
22625 wxPyEndAllowThreads(__tstate);
22626 if (PyErr_Occurred()) SWIG_fail;
22627 }
22628 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22629 return resultobj;
22630 fail:
22631 return NULL;
22632 }
22633
22634
22635 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22636 PyObject *resultobj = 0;
22637 wxDateTime result;
22638
22639 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22640 {
22641 PyThreadState* __tstate = wxPyBeginAllowThreads();
22642 result = wxDateTime::UNow();
22643 wxPyEndAllowThreads(__tstate);
22644 if (PyErr_Occurred()) SWIG_fail;
22645 }
22646 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22647 return resultobj;
22648 fail:
22649 return NULL;
22650 }
22651
22652
22653 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22654 PyObject *resultobj = 0;
22655 wxDateTime result;
22656
22657 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22658 {
22659 PyThreadState* __tstate = wxPyBeginAllowThreads();
22660 result = wxDateTime::Today();
22661 wxPyEndAllowThreads(__tstate);
22662 if (PyErr_Occurred()) SWIG_fail;
22663 }
22664 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22665 return resultobj;
22666 fail:
22667 return NULL;
22668 }
22669
22670
22671 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22672 PyObject *resultobj = 0;
22673 wxDateTime *result = 0 ;
22674
22675 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22676 {
22677 PyThreadState* __tstate = wxPyBeginAllowThreads();
22678 result = (wxDateTime *)new wxDateTime();
22679 wxPyEndAllowThreads(__tstate);
22680 if (PyErr_Occurred()) SWIG_fail;
22681 }
22682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22690 PyObject *resultobj = 0;
22691 time_t arg1 ;
22692 wxDateTime *result = 0 ;
22693 unsigned int val1 ;
22694 int ecode1 = 0 ;
22695 PyObject * obj0 = 0 ;
22696 char * kwnames[] = {
22697 (char *) "timet", NULL
22698 };
22699
22700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22701 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22702 if (!SWIG_IsOK(ecode1)) {
22703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22704 }
22705 arg1 = static_cast< time_t >(val1);
22706 {
22707 PyThreadState* __tstate = wxPyBeginAllowThreads();
22708 result = (wxDateTime *)new wxDateTime(arg1);
22709 wxPyEndAllowThreads(__tstate);
22710 if (PyErr_Occurred()) SWIG_fail;
22711 }
22712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22713 return resultobj;
22714 fail:
22715 return NULL;
22716 }
22717
22718
22719 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22720 PyObject *resultobj = 0;
22721 double arg1 ;
22722 wxDateTime *result = 0 ;
22723 double val1 ;
22724 int ecode1 = 0 ;
22725 PyObject * obj0 = 0 ;
22726 char * kwnames[] = {
22727 (char *) "jdn", NULL
22728 };
22729
22730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22731 ecode1 = SWIG_AsVal_double(obj0, &val1);
22732 if (!SWIG_IsOK(ecode1)) {
22733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22734 }
22735 arg1 = static_cast< double >(val1);
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = (wxDateTime *)new wxDateTime(arg1);
22739 wxPyEndAllowThreads(__tstate);
22740 if (PyErr_Occurred()) SWIG_fail;
22741 }
22742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22743 return resultobj;
22744 fail:
22745 return NULL;
22746 }
22747
22748
22749 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22750 PyObject *resultobj = 0;
22751 int arg1 ;
22752 int arg2 = (int) 0 ;
22753 int arg3 = (int) 0 ;
22754 int arg4 = (int) 0 ;
22755 wxDateTime *result = 0 ;
22756 int val1 ;
22757 int ecode1 = 0 ;
22758 int val2 ;
22759 int ecode2 = 0 ;
22760 int val3 ;
22761 int ecode3 = 0 ;
22762 int val4 ;
22763 int ecode4 = 0 ;
22764 PyObject * obj0 = 0 ;
22765 PyObject * obj1 = 0 ;
22766 PyObject * obj2 = 0 ;
22767 PyObject * obj3 = 0 ;
22768 char * kwnames[] = {
22769 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22770 };
22771
22772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22773 ecode1 = SWIG_AsVal_int(obj0, &val1);
22774 if (!SWIG_IsOK(ecode1)) {
22775 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22776 }
22777 arg1 = static_cast< int >(val1);
22778 if (obj1) {
22779 ecode2 = SWIG_AsVal_int(obj1, &val2);
22780 if (!SWIG_IsOK(ecode2)) {
22781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22782 }
22783 arg2 = static_cast< int >(val2);
22784 }
22785 if (obj2) {
22786 ecode3 = SWIG_AsVal_int(obj2, &val3);
22787 if (!SWIG_IsOK(ecode3)) {
22788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22789 }
22790 arg3 = static_cast< int >(val3);
22791 }
22792 if (obj3) {
22793 ecode4 = SWIG_AsVal_int(obj3, &val4);
22794 if (!SWIG_IsOK(ecode4)) {
22795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22796 }
22797 arg4 = static_cast< int >(val4);
22798 }
22799 {
22800 PyThreadState* __tstate = wxPyBeginAllowThreads();
22801 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22802 wxPyEndAllowThreads(__tstate);
22803 if (PyErr_Occurred()) SWIG_fail;
22804 }
22805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22813 PyObject *resultobj = 0;
22814 int arg1 ;
22815 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22816 int arg3 = (int) wxDateTime::Inv_Year ;
22817 int arg4 = (int) 0 ;
22818 int arg5 = (int) 0 ;
22819 int arg6 = (int) 0 ;
22820 int arg7 = (int) 0 ;
22821 wxDateTime *result = 0 ;
22822 int val1 ;
22823 int ecode1 = 0 ;
22824 int val2 ;
22825 int ecode2 = 0 ;
22826 int val3 ;
22827 int ecode3 = 0 ;
22828 int val4 ;
22829 int ecode4 = 0 ;
22830 int val5 ;
22831 int ecode5 = 0 ;
22832 int val6 ;
22833 int ecode6 = 0 ;
22834 int val7 ;
22835 int ecode7 = 0 ;
22836 PyObject * obj0 = 0 ;
22837 PyObject * obj1 = 0 ;
22838 PyObject * obj2 = 0 ;
22839 PyObject * obj3 = 0 ;
22840 PyObject * obj4 = 0 ;
22841 PyObject * obj5 = 0 ;
22842 PyObject * obj6 = 0 ;
22843 char * kwnames[] = {
22844 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22845 };
22846
22847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22848 ecode1 = SWIG_AsVal_int(obj0, &val1);
22849 if (!SWIG_IsOK(ecode1)) {
22850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22851 }
22852 arg1 = static_cast< int >(val1);
22853 if (obj1) {
22854 ecode2 = SWIG_AsVal_int(obj1, &val2);
22855 if (!SWIG_IsOK(ecode2)) {
22856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22857 }
22858 arg2 = static_cast< wxDateTime::Month >(val2);
22859 }
22860 if (obj2) {
22861 ecode3 = SWIG_AsVal_int(obj2, &val3);
22862 if (!SWIG_IsOK(ecode3)) {
22863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22864 }
22865 arg3 = static_cast< int >(val3);
22866 }
22867 if (obj3) {
22868 ecode4 = SWIG_AsVal_int(obj3, &val4);
22869 if (!SWIG_IsOK(ecode4)) {
22870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22871 }
22872 arg4 = static_cast< int >(val4);
22873 }
22874 if (obj4) {
22875 ecode5 = SWIG_AsVal_int(obj4, &val5);
22876 if (!SWIG_IsOK(ecode5)) {
22877 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22878 }
22879 arg5 = static_cast< int >(val5);
22880 }
22881 if (obj5) {
22882 ecode6 = SWIG_AsVal_int(obj5, &val6);
22883 if (!SWIG_IsOK(ecode6)) {
22884 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22885 }
22886 arg6 = static_cast< int >(val6);
22887 }
22888 if (obj6) {
22889 ecode7 = SWIG_AsVal_int(obj6, &val7);
22890 if (!SWIG_IsOK(ecode7)) {
22891 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22892 }
22893 arg7 = static_cast< int >(val7);
22894 }
22895 {
22896 PyThreadState* __tstate = wxPyBeginAllowThreads();
22897 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22898 wxPyEndAllowThreads(__tstate);
22899 if (PyErr_Occurred()) SWIG_fail;
22900 }
22901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22902 return resultobj;
22903 fail:
22904 return NULL;
22905 }
22906
22907
22908 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22909 PyObject *resultobj = 0;
22910 wxDateTime *arg1 = 0 ;
22911 wxDateTime *result = 0 ;
22912 void *argp1 = 0 ;
22913 int res1 = 0 ;
22914 PyObject * obj0 = 0 ;
22915 char * kwnames[] = {
22916 (char *) "date", NULL
22917 };
22918
22919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22920 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22921 if (!SWIG_IsOK(res1)) {
22922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22923 }
22924 if (!argp1) {
22925 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22926 }
22927 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22928 {
22929 PyThreadState* __tstate = wxPyBeginAllowThreads();
22930 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22931 wxPyEndAllowThreads(__tstate);
22932 if (PyErr_Occurred()) SWIG_fail;
22933 }
22934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22935 return resultobj;
22936 fail:
22937 return NULL;
22938 }
22939
22940
22941 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22942 PyObject *resultobj = 0;
22943 wxDateTime *arg1 = (wxDateTime *) 0 ;
22944 void *argp1 = 0 ;
22945 int res1 = 0 ;
22946 PyObject *swig_obj[1] ;
22947
22948 if (!args) SWIG_fail;
22949 swig_obj[0] = args;
22950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22951 if (!SWIG_IsOK(res1)) {
22952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22953 }
22954 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22955 {
22956 PyThreadState* __tstate = wxPyBeginAllowThreads();
22957 delete arg1;
22958
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 resultobj = SWIG_Py_Void();
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22970 PyObject *resultobj = 0;
22971 wxDateTime *arg1 = (wxDateTime *) 0 ;
22972 wxDateTime *result = 0 ;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 PyObject *swig_obj[1] ;
22976
22977 if (!args) SWIG_fail;
22978 swig_obj[0] = args;
22979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22980 if (!SWIG_IsOK(res1)) {
22981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22982 }
22983 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22984 {
22985 PyThreadState* __tstate = wxPyBeginAllowThreads();
22986 {
22987 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22988 result = (wxDateTime *) &_result_ref;
22989 }
22990 wxPyEndAllowThreads(__tstate);
22991 if (PyErr_Occurred()) SWIG_fail;
22992 }
22993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22994 return resultobj;
22995 fail:
22996 return NULL;
22997 }
22998
22999
23000 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23001 PyObject *resultobj = 0;
23002 wxDateTime *arg1 = (wxDateTime *) 0 ;
23003 time_t arg2 ;
23004 wxDateTime *result = 0 ;
23005 void *argp1 = 0 ;
23006 int res1 = 0 ;
23007 unsigned int val2 ;
23008 int ecode2 = 0 ;
23009 PyObject * obj0 = 0 ;
23010 PyObject * obj1 = 0 ;
23011 char * kwnames[] = {
23012 (char *) "self",(char *) "timet", NULL
23013 };
23014
23015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
23016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23017 if (!SWIG_IsOK(res1)) {
23018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
23019 }
23020 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23021 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
23022 if (!SWIG_IsOK(ecode2)) {
23023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
23024 }
23025 arg2 = static_cast< time_t >(val2);
23026 {
23027 PyThreadState* __tstate = wxPyBeginAllowThreads();
23028 {
23029 wxDateTime &_result_ref = (arg1)->Set(arg2);
23030 result = (wxDateTime *) &_result_ref;
23031 }
23032 wxPyEndAllowThreads(__tstate);
23033 if (PyErr_Occurred()) SWIG_fail;
23034 }
23035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23036 return resultobj;
23037 fail:
23038 return NULL;
23039 }
23040
23041
23042 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23043 PyObject *resultobj = 0;
23044 wxDateTime *arg1 = (wxDateTime *) 0 ;
23045 double arg2 ;
23046 wxDateTime *result = 0 ;
23047 void *argp1 = 0 ;
23048 int res1 = 0 ;
23049 double val2 ;
23050 int ecode2 = 0 ;
23051 PyObject * obj0 = 0 ;
23052 PyObject * obj1 = 0 ;
23053 char * kwnames[] = {
23054 (char *) "self",(char *) "jdn", NULL
23055 };
23056
23057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
23058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23059 if (!SWIG_IsOK(res1)) {
23060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
23061 }
23062 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23063 ecode2 = SWIG_AsVal_double(obj1, &val2);
23064 if (!SWIG_IsOK(ecode2)) {
23065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
23066 }
23067 arg2 = static_cast< double >(val2);
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 {
23071 wxDateTime &_result_ref = (arg1)->Set(arg2);
23072 result = (wxDateTime *) &_result_ref;
23073 }
23074 wxPyEndAllowThreads(__tstate);
23075 if (PyErr_Occurred()) SWIG_fail;
23076 }
23077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23078 return resultobj;
23079 fail:
23080 return NULL;
23081 }
23082
23083
23084 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23085 PyObject *resultobj = 0;
23086 wxDateTime *arg1 = (wxDateTime *) 0 ;
23087 int arg2 ;
23088 int arg3 = (int) 0 ;
23089 int arg4 = (int) 0 ;
23090 int arg5 = (int) 0 ;
23091 wxDateTime *result = 0 ;
23092 void *argp1 = 0 ;
23093 int res1 = 0 ;
23094 int val2 ;
23095 int ecode2 = 0 ;
23096 int val3 ;
23097 int ecode3 = 0 ;
23098 int val4 ;
23099 int ecode4 = 0 ;
23100 int val5 ;
23101 int ecode5 = 0 ;
23102 PyObject * obj0 = 0 ;
23103 PyObject * obj1 = 0 ;
23104 PyObject * obj2 = 0 ;
23105 PyObject * obj3 = 0 ;
23106 PyObject * obj4 = 0 ;
23107 char * kwnames[] = {
23108 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23109 };
23110
23111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23113 if (!SWIG_IsOK(res1)) {
23114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
23115 }
23116 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23117 ecode2 = SWIG_AsVal_int(obj1, &val2);
23118 if (!SWIG_IsOK(ecode2)) {
23119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
23120 }
23121 arg2 = static_cast< int >(val2);
23122 if (obj2) {
23123 ecode3 = SWIG_AsVal_int(obj2, &val3);
23124 if (!SWIG_IsOK(ecode3)) {
23125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
23126 }
23127 arg3 = static_cast< int >(val3);
23128 }
23129 if (obj3) {
23130 ecode4 = SWIG_AsVal_int(obj3, &val4);
23131 if (!SWIG_IsOK(ecode4)) {
23132 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
23133 }
23134 arg4 = static_cast< int >(val4);
23135 }
23136 if (obj4) {
23137 ecode5 = SWIG_AsVal_int(obj4, &val5);
23138 if (!SWIG_IsOK(ecode5)) {
23139 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
23140 }
23141 arg5 = static_cast< int >(val5);
23142 }
23143 {
23144 PyThreadState* __tstate = wxPyBeginAllowThreads();
23145 {
23146 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
23147 result = (wxDateTime *) &_result_ref;
23148 }
23149 wxPyEndAllowThreads(__tstate);
23150 if (PyErr_Occurred()) SWIG_fail;
23151 }
23152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23153 return resultobj;
23154 fail:
23155 return NULL;
23156 }
23157
23158
23159 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23160 PyObject *resultobj = 0;
23161 wxDateTime *arg1 = (wxDateTime *) 0 ;
23162 int arg2 ;
23163 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23164 int arg4 = (int) wxDateTime::Inv_Year ;
23165 int arg5 = (int) 0 ;
23166 int arg6 = (int) 0 ;
23167 int arg7 = (int) 0 ;
23168 int arg8 = (int) 0 ;
23169 wxDateTime *result = 0 ;
23170 void *argp1 = 0 ;
23171 int res1 = 0 ;
23172 int val2 ;
23173 int ecode2 = 0 ;
23174 int val3 ;
23175 int ecode3 = 0 ;
23176 int val4 ;
23177 int ecode4 = 0 ;
23178 int val5 ;
23179 int ecode5 = 0 ;
23180 int val6 ;
23181 int ecode6 = 0 ;
23182 int val7 ;
23183 int ecode7 = 0 ;
23184 int val8 ;
23185 int ecode8 = 0 ;
23186 PyObject * obj0 = 0 ;
23187 PyObject * obj1 = 0 ;
23188 PyObject * obj2 = 0 ;
23189 PyObject * obj3 = 0 ;
23190 PyObject * obj4 = 0 ;
23191 PyObject * obj5 = 0 ;
23192 PyObject * obj6 = 0 ;
23193 PyObject * obj7 = 0 ;
23194 char * kwnames[] = {
23195 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
23196 };
23197
23198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
23199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23200 if (!SWIG_IsOK(res1)) {
23201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
23202 }
23203 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23204 ecode2 = SWIG_AsVal_int(obj1, &val2);
23205 if (!SWIG_IsOK(ecode2)) {
23206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23207 }
23208 arg2 = static_cast< int >(val2);
23209 if (obj2) {
23210 ecode3 = SWIG_AsVal_int(obj2, &val3);
23211 if (!SWIG_IsOK(ecode3)) {
23212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23213 }
23214 arg3 = static_cast< wxDateTime::Month >(val3);
23215 }
23216 if (obj3) {
23217 ecode4 = SWIG_AsVal_int(obj3, &val4);
23218 if (!SWIG_IsOK(ecode4)) {
23219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23220 }
23221 arg4 = static_cast< int >(val4);
23222 }
23223 if (obj4) {
23224 ecode5 = SWIG_AsVal_int(obj4, &val5);
23225 if (!SWIG_IsOK(ecode5)) {
23226 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23227 }
23228 arg5 = static_cast< int >(val5);
23229 }
23230 if (obj5) {
23231 ecode6 = SWIG_AsVal_int(obj5, &val6);
23232 if (!SWIG_IsOK(ecode6)) {
23233 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23234 }
23235 arg6 = static_cast< int >(val6);
23236 }
23237 if (obj6) {
23238 ecode7 = SWIG_AsVal_int(obj6, &val7);
23239 if (!SWIG_IsOK(ecode7)) {
23240 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23241 }
23242 arg7 = static_cast< int >(val7);
23243 }
23244 if (obj7) {
23245 ecode8 = SWIG_AsVal_int(obj7, &val8);
23246 if (!SWIG_IsOK(ecode8)) {
23247 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23248 }
23249 arg8 = static_cast< int >(val8);
23250 }
23251 {
23252 PyThreadState* __tstate = wxPyBeginAllowThreads();
23253 {
23254 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23255 result = (wxDateTime *) &_result_ref;
23256 }
23257 wxPyEndAllowThreads(__tstate);
23258 if (PyErr_Occurred()) SWIG_fail;
23259 }
23260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23268 PyObject *resultobj = 0;
23269 wxDateTime *arg1 = (wxDateTime *) 0 ;
23270 wxDateTime *result = 0 ;
23271 void *argp1 = 0 ;
23272 int res1 = 0 ;
23273 PyObject *swig_obj[1] ;
23274
23275 if (!args) SWIG_fail;
23276 swig_obj[0] = args;
23277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23278 if (!SWIG_IsOK(res1)) {
23279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23280 }
23281 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 {
23285 wxDateTime &_result_ref = (arg1)->ResetTime();
23286 result = (wxDateTime *) &_result_ref;
23287 }
23288 wxPyEndAllowThreads(__tstate);
23289 if (PyErr_Occurred()) SWIG_fail;
23290 }
23291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23292 return resultobj;
23293 fail:
23294 return NULL;
23295 }
23296
23297
23298 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23299 PyObject *resultobj = 0;
23300 wxDateTime *arg1 = (wxDateTime *) 0 ;
23301 int arg2 ;
23302 wxDateTime *result = 0 ;
23303 void *argp1 = 0 ;
23304 int res1 = 0 ;
23305 int val2 ;
23306 int ecode2 = 0 ;
23307 PyObject * obj0 = 0 ;
23308 PyObject * obj1 = 0 ;
23309 char * kwnames[] = {
23310 (char *) "self",(char *) "year", NULL
23311 };
23312
23313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23315 if (!SWIG_IsOK(res1)) {
23316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23317 }
23318 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23319 ecode2 = SWIG_AsVal_int(obj1, &val2);
23320 if (!SWIG_IsOK(ecode2)) {
23321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23322 }
23323 arg2 = static_cast< int >(val2);
23324 {
23325 PyThreadState* __tstate = wxPyBeginAllowThreads();
23326 {
23327 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23328 result = (wxDateTime *) &_result_ref;
23329 }
23330 wxPyEndAllowThreads(__tstate);
23331 if (PyErr_Occurred()) SWIG_fail;
23332 }
23333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23341 PyObject *resultobj = 0;
23342 wxDateTime *arg1 = (wxDateTime *) 0 ;
23343 wxDateTime::Month arg2 ;
23344 wxDateTime *result = 0 ;
23345 void *argp1 = 0 ;
23346 int res1 = 0 ;
23347 int val2 ;
23348 int ecode2 = 0 ;
23349 PyObject * obj0 = 0 ;
23350 PyObject * obj1 = 0 ;
23351 char * kwnames[] = {
23352 (char *) "self",(char *) "month", NULL
23353 };
23354
23355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23357 if (!SWIG_IsOK(res1)) {
23358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23359 }
23360 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23361 ecode2 = SWIG_AsVal_int(obj1, &val2);
23362 if (!SWIG_IsOK(ecode2)) {
23363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23364 }
23365 arg2 = static_cast< wxDateTime::Month >(val2);
23366 {
23367 PyThreadState* __tstate = wxPyBeginAllowThreads();
23368 {
23369 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23370 result = (wxDateTime *) &_result_ref;
23371 }
23372 wxPyEndAllowThreads(__tstate);
23373 if (PyErr_Occurred()) SWIG_fail;
23374 }
23375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23376 return resultobj;
23377 fail:
23378 return NULL;
23379 }
23380
23381
23382 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23383 PyObject *resultobj = 0;
23384 wxDateTime *arg1 = (wxDateTime *) 0 ;
23385 int arg2 ;
23386 wxDateTime *result = 0 ;
23387 void *argp1 = 0 ;
23388 int res1 = 0 ;
23389 int val2 ;
23390 int ecode2 = 0 ;
23391 PyObject * obj0 = 0 ;
23392 PyObject * obj1 = 0 ;
23393 char * kwnames[] = {
23394 (char *) "self",(char *) "day", NULL
23395 };
23396
23397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23399 if (!SWIG_IsOK(res1)) {
23400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23401 }
23402 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23403 ecode2 = SWIG_AsVal_int(obj1, &val2);
23404 if (!SWIG_IsOK(ecode2)) {
23405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23406 }
23407 arg2 = static_cast< int >(val2);
23408 {
23409 PyThreadState* __tstate = wxPyBeginAllowThreads();
23410 {
23411 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23412 result = (wxDateTime *) &_result_ref;
23413 }
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23418 return resultobj;
23419 fail:
23420 return NULL;
23421 }
23422
23423
23424 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23425 PyObject *resultobj = 0;
23426 wxDateTime *arg1 = (wxDateTime *) 0 ;
23427 int arg2 ;
23428 wxDateTime *result = 0 ;
23429 void *argp1 = 0 ;
23430 int res1 = 0 ;
23431 int val2 ;
23432 int ecode2 = 0 ;
23433 PyObject * obj0 = 0 ;
23434 PyObject * obj1 = 0 ;
23435 char * kwnames[] = {
23436 (char *) "self",(char *) "hour", NULL
23437 };
23438
23439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23441 if (!SWIG_IsOK(res1)) {
23442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23443 }
23444 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23445 ecode2 = SWIG_AsVal_int(obj1, &val2);
23446 if (!SWIG_IsOK(ecode2)) {
23447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23448 }
23449 arg2 = static_cast< int >(val2);
23450 {
23451 PyThreadState* __tstate = wxPyBeginAllowThreads();
23452 {
23453 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23454 result = (wxDateTime *) &_result_ref;
23455 }
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23467 PyObject *resultobj = 0;
23468 wxDateTime *arg1 = (wxDateTime *) 0 ;
23469 int arg2 ;
23470 wxDateTime *result = 0 ;
23471 void *argp1 = 0 ;
23472 int res1 = 0 ;
23473 int val2 ;
23474 int ecode2 = 0 ;
23475 PyObject * obj0 = 0 ;
23476 PyObject * obj1 = 0 ;
23477 char * kwnames[] = {
23478 (char *) "self",(char *) "minute", NULL
23479 };
23480
23481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23483 if (!SWIG_IsOK(res1)) {
23484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23485 }
23486 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23487 ecode2 = SWIG_AsVal_int(obj1, &val2);
23488 if (!SWIG_IsOK(ecode2)) {
23489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23490 }
23491 arg2 = static_cast< int >(val2);
23492 {
23493 PyThreadState* __tstate = wxPyBeginAllowThreads();
23494 {
23495 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23496 result = (wxDateTime *) &_result_ref;
23497 }
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23509 PyObject *resultobj = 0;
23510 wxDateTime *arg1 = (wxDateTime *) 0 ;
23511 int arg2 ;
23512 wxDateTime *result = 0 ;
23513 void *argp1 = 0 ;
23514 int res1 = 0 ;
23515 int val2 ;
23516 int ecode2 = 0 ;
23517 PyObject * obj0 = 0 ;
23518 PyObject * obj1 = 0 ;
23519 char * kwnames[] = {
23520 (char *) "self",(char *) "second", NULL
23521 };
23522
23523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23525 if (!SWIG_IsOK(res1)) {
23526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23527 }
23528 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23529 ecode2 = SWIG_AsVal_int(obj1, &val2);
23530 if (!SWIG_IsOK(ecode2)) {
23531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23532 }
23533 arg2 = static_cast< int >(val2);
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 {
23537 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23538 result = (wxDateTime *) &_result_ref;
23539 }
23540 wxPyEndAllowThreads(__tstate);
23541 if (PyErr_Occurred()) SWIG_fail;
23542 }
23543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23544 return resultobj;
23545 fail:
23546 return NULL;
23547 }
23548
23549
23550 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23551 PyObject *resultobj = 0;
23552 wxDateTime *arg1 = (wxDateTime *) 0 ;
23553 int arg2 ;
23554 wxDateTime *result = 0 ;
23555 void *argp1 = 0 ;
23556 int res1 = 0 ;
23557 int val2 ;
23558 int ecode2 = 0 ;
23559 PyObject * obj0 = 0 ;
23560 PyObject * obj1 = 0 ;
23561 char * kwnames[] = {
23562 (char *) "self",(char *) "millisecond", NULL
23563 };
23564
23565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23567 if (!SWIG_IsOK(res1)) {
23568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23569 }
23570 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23571 ecode2 = SWIG_AsVal_int(obj1, &val2);
23572 if (!SWIG_IsOK(ecode2)) {
23573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23574 }
23575 arg2 = static_cast< int >(val2);
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 {
23579 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23580 result = (wxDateTime *) &_result_ref;
23581 }
23582 wxPyEndAllowThreads(__tstate);
23583 if (PyErr_Occurred()) SWIG_fail;
23584 }
23585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23586 return resultobj;
23587 fail:
23588 return NULL;
23589 }
23590
23591
23592 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23593 PyObject *resultobj = 0;
23594 wxDateTime *arg1 = (wxDateTime *) 0 ;
23595 wxDateTime::WeekDay arg2 ;
23596 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23597 wxDateTime *result = 0 ;
23598 void *argp1 = 0 ;
23599 int res1 = 0 ;
23600 int val2 ;
23601 int ecode2 = 0 ;
23602 int val3 ;
23603 int ecode3 = 0 ;
23604 PyObject * obj0 = 0 ;
23605 PyObject * obj1 = 0 ;
23606 PyObject * obj2 = 0 ;
23607 char * kwnames[] = {
23608 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23609 };
23610
23611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23613 if (!SWIG_IsOK(res1)) {
23614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23615 }
23616 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23617 ecode2 = SWIG_AsVal_int(obj1, &val2);
23618 if (!SWIG_IsOK(ecode2)) {
23619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23620 }
23621 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23622 if (obj2) {
23623 ecode3 = SWIG_AsVal_int(obj2, &val3);
23624 if (!SWIG_IsOK(ecode3)) {
23625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23626 }
23627 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23628 }
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 {
23632 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23633 result = (wxDateTime *) &_result_ref;
23634 }
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23646 PyObject *resultobj = 0;
23647 wxDateTime *arg1 = (wxDateTime *) 0 ;
23648 wxDateTime::WeekDay arg2 ;
23649 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23650 wxDateTime result;
23651 void *argp1 = 0 ;
23652 int res1 = 0 ;
23653 int val2 ;
23654 int ecode2 = 0 ;
23655 int val3 ;
23656 int ecode3 = 0 ;
23657 PyObject * obj0 = 0 ;
23658 PyObject * obj1 = 0 ;
23659 PyObject * obj2 = 0 ;
23660 char * kwnames[] = {
23661 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23662 };
23663
23664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23666 if (!SWIG_IsOK(res1)) {
23667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23668 }
23669 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23670 ecode2 = SWIG_AsVal_int(obj1, &val2);
23671 if (!SWIG_IsOK(ecode2)) {
23672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23673 }
23674 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23675 if (obj2) {
23676 ecode3 = SWIG_AsVal_int(obj2, &val3);
23677 if (!SWIG_IsOK(ecode3)) {
23678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23679 }
23680 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23681 }
23682 {
23683 PyThreadState* __tstate = wxPyBeginAllowThreads();
23684 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23689 return resultobj;
23690 fail:
23691 return NULL;
23692 }
23693
23694
23695 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23696 PyObject *resultobj = 0;
23697 wxDateTime *arg1 = (wxDateTime *) 0 ;
23698 wxDateTime::WeekDay arg2 ;
23699 wxDateTime *result = 0 ;
23700 void *argp1 = 0 ;
23701 int res1 = 0 ;
23702 int val2 ;
23703 int ecode2 = 0 ;
23704 PyObject * obj0 = 0 ;
23705 PyObject * obj1 = 0 ;
23706 char * kwnames[] = {
23707 (char *) "self",(char *) "weekday", NULL
23708 };
23709
23710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23712 if (!SWIG_IsOK(res1)) {
23713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23714 }
23715 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23716 ecode2 = SWIG_AsVal_int(obj1, &val2);
23717 if (!SWIG_IsOK(ecode2)) {
23718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23719 }
23720 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23721 {
23722 PyThreadState* __tstate = wxPyBeginAllowThreads();
23723 {
23724 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23725 result = (wxDateTime *) &_result_ref;
23726 }
23727 wxPyEndAllowThreads(__tstate);
23728 if (PyErr_Occurred()) SWIG_fail;
23729 }
23730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23738 PyObject *resultobj = 0;
23739 wxDateTime *arg1 = (wxDateTime *) 0 ;
23740 wxDateTime::WeekDay arg2 ;
23741 wxDateTime result;
23742 void *argp1 = 0 ;
23743 int res1 = 0 ;
23744 int val2 ;
23745 int ecode2 = 0 ;
23746 PyObject * obj0 = 0 ;
23747 PyObject * obj1 = 0 ;
23748 char * kwnames[] = {
23749 (char *) "self",(char *) "weekday", NULL
23750 };
23751
23752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23754 if (!SWIG_IsOK(res1)) {
23755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23756 }
23757 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23758 ecode2 = SWIG_AsVal_int(obj1, &val2);
23759 if (!SWIG_IsOK(ecode2)) {
23760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23761 }
23762 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23763 {
23764 PyThreadState* __tstate = wxPyBeginAllowThreads();
23765 result = (arg1)->GetNextWeekDay(arg2);
23766 wxPyEndAllowThreads(__tstate);
23767 if (PyErr_Occurred()) SWIG_fail;
23768 }
23769 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23770 return resultobj;
23771 fail:
23772 return NULL;
23773 }
23774
23775
23776 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23777 PyObject *resultobj = 0;
23778 wxDateTime *arg1 = (wxDateTime *) 0 ;
23779 wxDateTime::WeekDay arg2 ;
23780 wxDateTime *result = 0 ;
23781 void *argp1 = 0 ;
23782 int res1 = 0 ;
23783 int val2 ;
23784 int ecode2 = 0 ;
23785 PyObject * obj0 = 0 ;
23786 PyObject * obj1 = 0 ;
23787 char * kwnames[] = {
23788 (char *) "self",(char *) "weekday", NULL
23789 };
23790
23791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23793 if (!SWIG_IsOK(res1)) {
23794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23795 }
23796 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23797 ecode2 = SWIG_AsVal_int(obj1, &val2);
23798 if (!SWIG_IsOK(ecode2)) {
23799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23800 }
23801 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 {
23805 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23806 result = (wxDateTime *) &_result_ref;
23807 }
23808 wxPyEndAllowThreads(__tstate);
23809 if (PyErr_Occurred()) SWIG_fail;
23810 }
23811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj = 0;
23820 wxDateTime *arg1 = (wxDateTime *) 0 ;
23821 wxDateTime::WeekDay arg2 ;
23822 wxDateTime result;
23823 void *argp1 = 0 ;
23824 int res1 = 0 ;
23825 int val2 ;
23826 int ecode2 = 0 ;
23827 PyObject * obj0 = 0 ;
23828 PyObject * obj1 = 0 ;
23829 char * kwnames[] = {
23830 (char *) "self",(char *) "weekday", NULL
23831 };
23832
23833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23837 }
23838 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23839 ecode2 = SWIG_AsVal_int(obj1, &val2);
23840 if (!SWIG_IsOK(ecode2)) {
23841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23842 }
23843 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23844 {
23845 PyThreadState* __tstate = wxPyBeginAllowThreads();
23846 result = (arg1)->GetPrevWeekDay(arg2);
23847 wxPyEndAllowThreads(__tstate);
23848 if (PyErr_Occurred()) SWIG_fail;
23849 }
23850 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23851 return resultobj;
23852 fail:
23853 return NULL;
23854 }
23855
23856
23857 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23858 PyObject *resultobj = 0;
23859 wxDateTime *arg1 = (wxDateTime *) 0 ;
23860 wxDateTime::WeekDay arg2 ;
23861 int arg3 = (int) 1 ;
23862 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23863 int arg5 = (int) wxDateTime::Inv_Year ;
23864 bool result;
23865 void *argp1 = 0 ;
23866 int res1 = 0 ;
23867 int val2 ;
23868 int ecode2 = 0 ;
23869 int val3 ;
23870 int ecode3 = 0 ;
23871 int val4 ;
23872 int ecode4 = 0 ;
23873 int val5 ;
23874 int ecode5 = 0 ;
23875 PyObject * obj0 = 0 ;
23876 PyObject * obj1 = 0 ;
23877 PyObject * obj2 = 0 ;
23878 PyObject * obj3 = 0 ;
23879 PyObject * obj4 = 0 ;
23880 char * kwnames[] = {
23881 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23882 };
23883
23884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23886 if (!SWIG_IsOK(res1)) {
23887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23888 }
23889 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23890 ecode2 = SWIG_AsVal_int(obj1, &val2);
23891 if (!SWIG_IsOK(ecode2)) {
23892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23893 }
23894 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23895 if (obj2) {
23896 ecode3 = SWIG_AsVal_int(obj2, &val3);
23897 if (!SWIG_IsOK(ecode3)) {
23898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23899 }
23900 arg3 = static_cast< int >(val3);
23901 }
23902 if (obj3) {
23903 ecode4 = SWIG_AsVal_int(obj3, &val4);
23904 if (!SWIG_IsOK(ecode4)) {
23905 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23906 }
23907 arg4 = static_cast< wxDateTime::Month >(val4);
23908 }
23909 if (obj4) {
23910 ecode5 = SWIG_AsVal_int(obj4, &val5);
23911 if (!SWIG_IsOK(ecode5)) {
23912 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23913 }
23914 arg5 = static_cast< int >(val5);
23915 }
23916 {
23917 PyThreadState* __tstate = wxPyBeginAllowThreads();
23918 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 {
23923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23924 }
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23932 PyObject *resultobj = 0;
23933 wxDateTime *arg1 = (wxDateTime *) 0 ;
23934 wxDateTime::WeekDay arg2 ;
23935 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23936 int arg4 = (int) wxDateTime::Inv_Year ;
23937 bool result;
23938 void *argp1 = 0 ;
23939 int res1 = 0 ;
23940 int val2 ;
23941 int ecode2 = 0 ;
23942 int val3 ;
23943 int ecode3 = 0 ;
23944 int val4 ;
23945 int ecode4 = 0 ;
23946 PyObject * obj0 = 0 ;
23947 PyObject * obj1 = 0 ;
23948 PyObject * obj2 = 0 ;
23949 PyObject * obj3 = 0 ;
23950 char * kwnames[] = {
23951 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23952 };
23953
23954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23956 if (!SWIG_IsOK(res1)) {
23957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23958 }
23959 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23960 ecode2 = SWIG_AsVal_int(obj1, &val2);
23961 if (!SWIG_IsOK(ecode2)) {
23962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23963 }
23964 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23965 if (obj2) {
23966 ecode3 = SWIG_AsVal_int(obj2, &val3);
23967 if (!SWIG_IsOK(ecode3)) {
23968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23969 }
23970 arg3 = static_cast< wxDateTime::Month >(val3);
23971 }
23972 if (obj3) {
23973 ecode4 = SWIG_AsVal_int(obj3, &val4);
23974 if (!SWIG_IsOK(ecode4)) {
23975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23976 }
23977 arg4 = static_cast< int >(val4);
23978 }
23979 {
23980 PyThreadState* __tstate = wxPyBeginAllowThreads();
23981 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23982 wxPyEndAllowThreads(__tstate);
23983 if (PyErr_Occurred()) SWIG_fail;
23984 }
23985 {
23986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23987 }
23988 return resultobj;
23989 fail:
23990 return NULL;
23991 }
23992
23993
23994 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23995 PyObject *resultobj = 0;
23996 wxDateTime *arg1 = (wxDateTime *) 0 ;
23997 wxDateTime::WeekDay arg2 ;
23998 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23999 int arg4 = (int) wxDateTime::Inv_Year ;
24000 wxDateTime result;
24001 void *argp1 = 0 ;
24002 int res1 = 0 ;
24003 int val2 ;
24004 int ecode2 = 0 ;
24005 int val3 ;
24006 int ecode3 = 0 ;
24007 int val4 ;
24008 int ecode4 = 0 ;
24009 PyObject * obj0 = 0 ;
24010 PyObject * obj1 = 0 ;
24011 PyObject * obj2 = 0 ;
24012 PyObject * obj3 = 0 ;
24013 char * kwnames[] = {
24014 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
24015 };
24016
24017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24019 if (!SWIG_IsOK(res1)) {
24020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24021 }
24022 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24023 ecode2 = SWIG_AsVal_int(obj1, &val2);
24024 if (!SWIG_IsOK(ecode2)) {
24025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
24026 }
24027 arg2 = static_cast< wxDateTime::WeekDay >(val2);
24028 if (obj2) {
24029 ecode3 = SWIG_AsVal_int(obj2, &val3);
24030 if (!SWIG_IsOK(ecode3)) {
24031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
24032 }
24033 arg3 = static_cast< wxDateTime::Month >(val3);
24034 }
24035 if (obj3) {
24036 ecode4 = SWIG_AsVal_int(obj3, &val4);
24037 if (!SWIG_IsOK(ecode4)) {
24038 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
24039 }
24040 arg4 = static_cast< int >(val4);
24041 }
24042 {
24043 PyThreadState* __tstate = wxPyBeginAllowThreads();
24044 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
24045 wxPyEndAllowThreads(__tstate);
24046 if (PyErr_Occurred()) SWIG_fail;
24047 }
24048 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24049 return resultobj;
24050 fail:
24051 return NULL;
24052 }
24053
24054
24055 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24056 PyObject *resultobj = 0;
24057 wxDateTime *arg1 = (wxDateTime *) 0 ;
24058 int arg2 ;
24059 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24060 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24061 bool result;
24062 void *argp1 = 0 ;
24063 int res1 = 0 ;
24064 int val2 ;
24065 int ecode2 = 0 ;
24066 int val3 ;
24067 int ecode3 = 0 ;
24068 int val4 ;
24069 int ecode4 = 0 ;
24070 PyObject * obj0 = 0 ;
24071 PyObject * obj1 = 0 ;
24072 PyObject * obj2 = 0 ;
24073 PyObject * obj3 = 0 ;
24074 char * kwnames[] = {
24075 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24076 };
24077
24078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24080 if (!SWIG_IsOK(res1)) {
24081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24082 }
24083 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24084 ecode2 = SWIG_AsVal_int(obj1, &val2);
24085 if (!SWIG_IsOK(ecode2)) {
24086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
24087 }
24088 arg2 = static_cast< int >(val2);
24089 if (obj2) {
24090 ecode3 = SWIG_AsVal_int(obj2, &val3);
24091 if (!SWIG_IsOK(ecode3)) {
24092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24093 }
24094 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24095 }
24096 if (obj3) {
24097 ecode4 = SWIG_AsVal_int(obj3, &val4);
24098 if (!SWIG_IsOK(ecode4)) {
24099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24100 }
24101 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24102 }
24103 {
24104 PyThreadState* __tstate = wxPyBeginAllowThreads();
24105 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
24106 wxPyEndAllowThreads(__tstate);
24107 if (PyErr_Occurred()) SWIG_fail;
24108 }
24109 {
24110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24111 }
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj = 0;
24120 wxDateTime *arg1 = (wxDateTime *) 0 ;
24121 int arg2 ;
24122 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24123 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
24124 wxDateTime result;
24125 void *argp1 = 0 ;
24126 int res1 = 0 ;
24127 int val2 ;
24128 int ecode2 = 0 ;
24129 int val3 ;
24130 int ecode3 = 0 ;
24131 int val4 ;
24132 int ecode4 = 0 ;
24133 PyObject * obj0 = 0 ;
24134 PyObject * obj1 = 0 ;
24135 PyObject * obj2 = 0 ;
24136 PyObject * obj3 = 0 ;
24137 char * kwnames[] = {
24138 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
24139 };
24140
24141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
24142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24143 if (!SWIG_IsOK(res1)) {
24144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
24145 }
24146 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24147 ecode2 = SWIG_AsVal_int(obj1, &val2);
24148 if (!SWIG_IsOK(ecode2)) {
24149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
24150 }
24151 arg2 = static_cast< int >(val2);
24152 if (obj2) {
24153 ecode3 = SWIG_AsVal_int(obj2, &val3);
24154 if (!SWIG_IsOK(ecode3)) {
24155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24156 }
24157 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24158 }
24159 if (obj3) {
24160 ecode4 = SWIG_AsVal_int(obj3, &val4);
24161 if (!SWIG_IsOK(ecode4)) {
24162 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
24163 }
24164 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
24165 }
24166 {
24167 PyThreadState* __tstate = wxPyBeginAllowThreads();
24168 result = (arg1)->GetWeek(arg2,arg3,arg4);
24169 wxPyEndAllowThreads(__tstate);
24170 if (PyErr_Occurred()) SWIG_fail;
24171 }
24172 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24173 return resultobj;
24174 fail:
24175 return NULL;
24176 }
24177
24178
24179 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24180 PyObject *resultobj = 0;
24181 int arg1 ;
24182 int arg2 ;
24183 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
24184 wxDateTime result;
24185 int val1 ;
24186 int ecode1 = 0 ;
24187 int val2 ;
24188 int ecode2 = 0 ;
24189 int val3 ;
24190 int ecode3 = 0 ;
24191 PyObject * obj0 = 0 ;
24192 PyObject * obj1 = 0 ;
24193 PyObject * obj2 = 0 ;
24194 char * kwnames[] = {
24195 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
24196 };
24197
24198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24199 ecode1 = SWIG_AsVal_int(obj0, &val1);
24200 if (!SWIG_IsOK(ecode1)) {
24201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
24202 }
24203 arg1 = static_cast< int >(val1);
24204 ecode2 = SWIG_AsVal_int(obj1, &val2);
24205 if (!SWIG_IsOK(ecode2)) {
24206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24207 }
24208 arg2 = static_cast< int >(val2);
24209 if (obj2) {
24210 ecode3 = SWIG_AsVal_int(obj2, &val3);
24211 if (!SWIG_IsOK(ecode3)) {
24212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24213 }
24214 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24215 }
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24219 wxPyEndAllowThreads(__tstate);
24220 if (PyErr_Occurred()) SWIG_fail;
24221 }
24222 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24223 return resultobj;
24224 fail:
24225 return NULL;
24226 }
24227
24228
24229 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24230 PyObject *resultobj = 0;
24231 wxDateTime *arg1 = (wxDateTime *) 0 ;
24232 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24233 int arg3 = (int) wxDateTime::Inv_Year ;
24234 wxDateTime *result = 0 ;
24235 void *argp1 = 0 ;
24236 int res1 = 0 ;
24237 int val2 ;
24238 int ecode2 = 0 ;
24239 int val3 ;
24240 int ecode3 = 0 ;
24241 PyObject * obj0 = 0 ;
24242 PyObject * obj1 = 0 ;
24243 PyObject * obj2 = 0 ;
24244 char * kwnames[] = {
24245 (char *) "self",(char *) "month",(char *) "year", NULL
24246 };
24247
24248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24250 if (!SWIG_IsOK(res1)) {
24251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24252 }
24253 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24254 if (obj1) {
24255 ecode2 = SWIG_AsVal_int(obj1, &val2);
24256 if (!SWIG_IsOK(ecode2)) {
24257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24258 }
24259 arg2 = static_cast< wxDateTime::Month >(val2);
24260 }
24261 if (obj2) {
24262 ecode3 = SWIG_AsVal_int(obj2, &val3);
24263 if (!SWIG_IsOK(ecode3)) {
24264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24265 }
24266 arg3 = static_cast< int >(val3);
24267 }
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 {
24271 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24272 result = (wxDateTime *) &_result_ref;
24273 }
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24285 PyObject *resultobj = 0;
24286 wxDateTime *arg1 = (wxDateTime *) 0 ;
24287 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24288 int arg3 = (int) wxDateTime::Inv_Year ;
24289 wxDateTime result;
24290 void *argp1 = 0 ;
24291 int res1 = 0 ;
24292 int val2 ;
24293 int ecode2 = 0 ;
24294 int val3 ;
24295 int ecode3 = 0 ;
24296 PyObject * obj0 = 0 ;
24297 PyObject * obj1 = 0 ;
24298 PyObject * obj2 = 0 ;
24299 char * kwnames[] = {
24300 (char *) "self",(char *) "month",(char *) "year", NULL
24301 };
24302
24303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24307 }
24308 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24309 if (obj1) {
24310 ecode2 = SWIG_AsVal_int(obj1, &val2);
24311 if (!SWIG_IsOK(ecode2)) {
24312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24313 }
24314 arg2 = static_cast< wxDateTime::Month >(val2);
24315 }
24316 if (obj2) {
24317 ecode3 = SWIG_AsVal_int(obj2, &val3);
24318 if (!SWIG_IsOK(ecode3)) {
24319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24320 }
24321 arg3 = static_cast< int >(val3);
24322 }
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 result = (arg1)->GetLastMonthDay(arg2,arg3);
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24330 return resultobj;
24331 fail:
24332 return NULL;
24333 }
24334
24335
24336 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24337 PyObject *resultobj = 0;
24338 wxDateTime *arg1 = (wxDateTime *) 0 ;
24339 int arg2 ;
24340 wxDateTime *result = 0 ;
24341 void *argp1 = 0 ;
24342 int res1 = 0 ;
24343 int val2 ;
24344 int ecode2 = 0 ;
24345 PyObject * obj0 = 0 ;
24346 PyObject * obj1 = 0 ;
24347 char * kwnames[] = {
24348 (char *) "self",(char *) "yday", NULL
24349 };
24350
24351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24353 if (!SWIG_IsOK(res1)) {
24354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24355 }
24356 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24357 ecode2 = SWIG_AsVal_int(obj1, &val2);
24358 if (!SWIG_IsOK(ecode2)) {
24359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24360 }
24361 arg2 = static_cast< int >(val2);
24362 {
24363 PyThreadState* __tstate = wxPyBeginAllowThreads();
24364 {
24365 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24366 result = (wxDateTime *) &_result_ref;
24367 }
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24379 PyObject *resultobj = 0;
24380 wxDateTime *arg1 = (wxDateTime *) 0 ;
24381 int arg2 ;
24382 wxDateTime result;
24383 void *argp1 = 0 ;
24384 int res1 = 0 ;
24385 int val2 ;
24386 int ecode2 = 0 ;
24387 PyObject * obj0 = 0 ;
24388 PyObject * obj1 = 0 ;
24389 char * kwnames[] = {
24390 (char *) "self",(char *) "yday", NULL
24391 };
24392
24393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24395 if (!SWIG_IsOK(res1)) {
24396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24397 }
24398 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24399 ecode2 = SWIG_AsVal_int(obj1, &val2);
24400 if (!SWIG_IsOK(ecode2)) {
24401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24402 }
24403 arg2 = static_cast< int >(val2);
24404 {
24405 PyThreadState* __tstate = wxPyBeginAllowThreads();
24406 result = (arg1)->GetYearDay(arg2);
24407 wxPyEndAllowThreads(__tstate);
24408 if (PyErr_Occurred()) SWIG_fail;
24409 }
24410 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24411 return resultobj;
24412 fail:
24413 return NULL;
24414 }
24415
24416
24417 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24418 PyObject *resultobj = 0;
24419 wxDateTime *arg1 = (wxDateTime *) 0 ;
24420 double result;
24421 void *argp1 = 0 ;
24422 int res1 = 0 ;
24423 PyObject *swig_obj[1] ;
24424
24425 if (!args) SWIG_fail;
24426 swig_obj[0] = args;
24427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24428 if (!SWIG_IsOK(res1)) {
24429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24430 }
24431 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24432 {
24433 PyThreadState* __tstate = wxPyBeginAllowThreads();
24434 result = (double)(arg1)->GetJulianDayNumber();
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 resultobj = SWIG_From_double(static_cast< double >(result));
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24446 PyObject *resultobj = 0;
24447 wxDateTime *arg1 = (wxDateTime *) 0 ;
24448 double result;
24449 void *argp1 = 0 ;
24450 int res1 = 0 ;
24451 PyObject *swig_obj[1] ;
24452
24453 if (!args) SWIG_fail;
24454 swig_obj[0] = args;
24455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24456 if (!SWIG_IsOK(res1)) {
24457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24458 }
24459 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24460 {
24461 PyThreadState* __tstate = wxPyBeginAllowThreads();
24462 result = (double)(arg1)->GetJDN();
24463 wxPyEndAllowThreads(__tstate);
24464 if (PyErr_Occurred()) SWIG_fail;
24465 }
24466 resultobj = SWIG_From_double(static_cast< double >(result));
24467 return resultobj;
24468 fail:
24469 return NULL;
24470 }
24471
24472
24473 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24474 PyObject *resultobj = 0;
24475 wxDateTime *arg1 = (wxDateTime *) 0 ;
24476 double result;
24477 void *argp1 = 0 ;
24478 int res1 = 0 ;
24479 PyObject *swig_obj[1] ;
24480
24481 if (!args) SWIG_fail;
24482 swig_obj[0] = args;
24483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24484 if (!SWIG_IsOK(res1)) {
24485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24486 }
24487 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24488 {
24489 PyThreadState* __tstate = wxPyBeginAllowThreads();
24490 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24491 wxPyEndAllowThreads(__tstate);
24492 if (PyErr_Occurred()) SWIG_fail;
24493 }
24494 resultobj = SWIG_From_double(static_cast< double >(result));
24495 return resultobj;
24496 fail:
24497 return NULL;
24498 }
24499
24500
24501 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24502 PyObject *resultobj = 0;
24503 wxDateTime *arg1 = (wxDateTime *) 0 ;
24504 double result;
24505 void *argp1 = 0 ;
24506 int res1 = 0 ;
24507 PyObject *swig_obj[1] ;
24508
24509 if (!args) SWIG_fail;
24510 swig_obj[0] = args;
24511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24512 if (!SWIG_IsOK(res1)) {
24513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24514 }
24515 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24516 {
24517 PyThreadState* __tstate = wxPyBeginAllowThreads();
24518 result = (double)(arg1)->GetMJD();
24519 wxPyEndAllowThreads(__tstate);
24520 if (PyErr_Occurred()) SWIG_fail;
24521 }
24522 resultobj = SWIG_From_double(static_cast< double >(result));
24523 return resultobj;
24524 fail:
24525 return NULL;
24526 }
24527
24528
24529 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24530 PyObject *resultobj = 0;
24531 wxDateTime *arg1 = (wxDateTime *) 0 ;
24532 double result;
24533 void *argp1 = 0 ;
24534 int res1 = 0 ;
24535 PyObject *swig_obj[1] ;
24536
24537 if (!args) SWIG_fail;
24538 swig_obj[0] = args;
24539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24540 if (!SWIG_IsOK(res1)) {
24541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24542 }
24543 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24544 {
24545 PyThreadState* __tstate = wxPyBeginAllowThreads();
24546 result = (double)(arg1)->GetRataDie();
24547 wxPyEndAllowThreads(__tstate);
24548 if (PyErr_Occurred()) SWIG_fail;
24549 }
24550 resultobj = SWIG_From_double(static_cast< double >(result));
24551 return resultobj;
24552 fail:
24553 return NULL;
24554 }
24555
24556
24557 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24558 PyObject *resultobj = 0;
24559 wxDateTime *arg1 = (wxDateTime *) 0 ;
24560 wxDateTime::TimeZone *arg2 = 0 ;
24561 bool arg3 = (bool) false ;
24562 wxDateTime result;
24563 void *argp1 = 0 ;
24564 int res1 = 0 ;
24565 bool temp2 = false ;
24566 bool val3 ;
24567 int ecode3 = 0 ;
24568 PyObject * obj0 = 0 ;
24569 PyObject * obj1 = 0 ;
24570 PyObject * obj2 = 0 ;
24571 char * kwnames[] = {
24572 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24573 };
24574
24575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24577 if (!SWIG_IsOK(res1)) {
24578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24579 }
24580 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24581 {
24582 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24583 temp2 = true;
24584 }
24585 if (obj2) {
24586 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24587 if (!SWIG_IsOK(ecode3)) {
24588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24589 }
24590 arg3 = static_cast< bool >(val3);
24591 }
24592 {
24593 PyThreadState* __tstate = wxPyBeginAllowThreads();
24594 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24595 wxPyEndAllowThreads(__tstate);
24596 if (PyErr_Occurred()) SWIG_fail;
24597 }
24598 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24599 {
24600 if (temp2) delete arg2;
24601 }
24602 return resultobj;
24603 fail:
24604 {
24605 if (temp2) delete arg2;
24606 }
24607 return NULL;
24608 }
24609
24610
24611 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24612 PyObject *resultobj = 0;
24613 wxDateTime *arg1 = (wxDateTime *) 0 ;
24614 wxDateTime::TimeZone *arg2 = 0 ;
24615 bool arg3 = (bool) false ;
24616 wxDateTime *result = 0 ;
24617 void *argp1 = 0 ;
24618 int res1 = 0 ;
24619 bool temp2 = false ;
24620 bool val3 ;
24621 int ecode3 = 0 ;
24622 PyObject * obj0 = 0 ;
24623 PyObject * obj1 = 0 ;
24624 PyObject * obj2 = 0 ;
24625 char * kwnames[] = {
24626 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24627 };
24628
24629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24631 if (!SWIG_IsOK(res1)) {
24632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24633 }
24634 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24635 {
24636 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24637 temp2 = true;
24638 }
24639 if (obj2) {
24640 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24641 if (!SWIG_IsOK(ecode3)) {
24642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24643 }
24644 arg3 = static_cast< bool >(val3);
24645 }
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 {
24649 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24650 result = (wxDateTime *) &_result_ref;
24651 }
24652 wxPyEndAllowThreads(__tstate);
24653 if (PyErr_Occurred()) SWIG_fail;
24654 }
24655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24656 {
24657 if (temp2) delete arg2;
24658 }
24659 return resultobj;
24660 fail:
24661 {
24662 if (temp2) delete arg2;
24663 }
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj = 0;
24670 wxDateTime *arg1 = (wxDateTime *) 0 ;
24671 wxDateTime::TimeZone *arg2 = 0 ;
24672 bool arg3 = (bool) false ;
24673 wxDateTime result;
24674 void *argp1 = 0 ;
24675 int res1 = 0 ;
24676 bool temp2 = false ;
24677 bool val3 ;
24678 int ecode3 = 0 ;
24679 PyObject * obj0 = 0 ;
24680 PyObject * obj1 = 0 ;
24681 PyObject * obj2 = 0 ;
24682 char * kwnames[] = {
24683 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24684 };
24685
24686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24688 if (!SWIG_IsOK(res1)) {
24689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24690 }
24691 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24692 {
24693 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24694 temp2 = true;
24695 }
24696 if (obj2) {
24697 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24698 if (!SWIG_IsOK(ecode3)) {
24699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24700 }
24701 arg3 = static_cast< bool >(val3);
24702 }
24703 {
24704 PyThreadState* __tstate = wxPyBeginAllowThreads();
24705 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24706 wxPyEndAllowThreads(__tstate);
24707 if (PyErr_Occurred()) SWIG_fail;
24708 }
24709 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24710 {
24711 if (temp2) delete arg2;
24712 }
24713 return resultobj;
24714 fail:
24715 {
24716 if (temp2) delete arg2;
24717 }
24718 return NULL;
24719 }
24720
24721
24722 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24723 PyObject *resultobj = 0;
24724 wxDateTime *arg1 = (wxDateTime *) 0 ;
24725 wxDateTime::TimeZone *arg2 = 0 ;
24726 bool arg3 = (bool) false ;
24727 wxDateTime *result = 0 ;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 bool temp2 = false ;
24731 bool val3 ;
24732 int ecode3 = 0 ;
24733 PyObject * obj0 = 0 ;
24734 PyObject * obj1 = 0 ;
24735 PyObject * obj2 = 0 ;
24736 char * kwnames[] = {
24737 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24738 };
24739
24740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24742 if (!SWIG_IsOK(res1)) {
24743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24744 }
24745 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24746 {
24747 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24748 temp2 = true;
24749 }
24750 if (obj2) {
24751 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24752 if (!SWIG_IsOK(ecode3)) {
24753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24754 }
24755 arg3 = static_cast< bool >(val3);
24756 }
24757 {
24758 PyThreadState* __tstate = wxPyBeginAllowThreads();
24759 {
24760 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24761 result = (wxDateTime *) &_result_ref;
24762 }
24763 wxPyEndAllowThreads(__tstate);
24764 if (PyErr_Occurred()) SWIG_fail;
24765 }
24766 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24767 {
24768 if (temp2) delete arg2;
24769 }
24770 return resultobj;
24771 fail:
24772 {
24773 if (temp2) delete arg2;
24774 }
24775 return NULL;
24776 }
24777
24778
24779 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24780 PyObject *resultobj = 0;
24781 wxDateTime *arg1 = (wxDateTime *) 0 ;
24782 bool arg2 = (bool) false ;
24783 wxDateTime result;
24784 void *argp1 = 0 ;
24785 int res1 = 0 ;
24786 bool val2 ;
24787 int ecode2 = 0 ;
24788 PyObject * obj0 = 0 ;
24789 PyObject * obj1 = 0 ;
24790 char * kwnames[] = {
24791 (char *) "self",(char *) "noDST", NULL
24792 };
24793
24794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24796 if (!SWIG_IsOK(res1)) {
24797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24798 }
24799 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24800 if (obj1) {
24801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24802 if (!SWIG_IsOK(ecode2)) {
24803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24804 }
24805 arg2 = static_cast< bool >(val2);
24806 }
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24810 wxPyEndAllowThreads(__tstate);
24811 if (PyErr_Occurred()) SWIG_fail;
24812 }
24813 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24821 PyObject *resultobj = 0;
24822 wxDateTime *arg1 = (wxDateTime *) 0 ;
24823 bool arg2 = (bool) false ;
24824 wxDateTime *result = 0 ;
24825 void *argp1 = 0 ;
24826 int res1 = 0 ;
24827 bool val2 ;
24828 int ecode2 = 0 ;
24829 PyObject * obj0 = 0 ;
24830 PyObject * obj1 = 0 ;
24831 char * kwnames[] = {
24832 (char *) "self",(char *) "noDST", NULL
24833 };
24834
24835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24837 if (!SWIG_IsOK(res1)) {
24838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24839 }
24840 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24841 if (obj1) {
24842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24843 if (!SWIG_IsOK(ecode2)) {
24844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24845 }
24846 arg2 = static_cast< bool >(val2);
24847 }
24848 {
24849 PyThreadState* __tstate = wxPyBeginAllowThreads();
24850 {
24851 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24852 result = (wxDateTime *) &_result_ref;
24853 }
24854 wxPyEndAllowThreads(__tstate);
24855 if (PyErr_Occurred()) SWIG_fail;
24856 }
24857 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24865 PyObject *resultobj = 0;
24866 wxDateTime *arg1 = (wxDateTime *) 0 ;
24867 bool arg2 = (bool) false ;
24868 wxDateTime result;
24869 void *argp1 = 0 ;
24870 int res1 = 0 ;
24871 bool val2 ;
24872 int ecode2 = 0 ;
24873 PyObject * obj0 = 0 ;
24874 PyObject * obj1 = 0 ;
24875 char * kwnames[] = {
24876 (char *) "self",(char *) "noDST", NULL
24877 };
24878
24879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24881 if (!SWIG_IsOK(res1)) {
24882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24883 }
24884 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24885 if (obj1) {
24886 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24887 if (!SWIG_IsOK(ecode2)) {
24888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24889 }
24890 arg2 = static_cast< bool >(val2);
24891 }
24892 {
24893 PyThreadState* __tstate = wxPyBeginAllowThreads();
24894 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24895 wxPyEndAllowThreads(__tstate);
24896 if (PyErr_Occurred()) SWIG_fail;
24897 }
24898 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24899 return resultobj;
24900 fail:
24901 return NULL;
24902 }
24903
24904
24905 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24906 PyObject *resultobj = 0;
24907 wxDateTime *arg1 = (wxDateTime *) 0 ;
24908 bool arg2 = (bool) false ;
24909 wxDateTime *result = 0 ;
24910 void *argp1 = 0 ;
24911 int res1 = 0 ;
24912 bool val2 ;
24913 int ecode2 = 0 ;
24914 PyObject * obj0 = 0 ;
24915 PyObject * obj1 = 0 ;
24916 char * kwnames[] = {
24917 (char *) "self",(char *) "noDST", NULL
24918 };
24919
24920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24922 if (!SWIG_IsOK(res1)) {
24923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24924 }
24925 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24926 if (obj1) {
24927 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24928 if (!SWIG_IsOK(ecode2)) {
24929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24930 }
24931 arg2 = static_cast< bool >(val2);
24932 }
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 {
24936 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24937 result = (wxDateTime *) &_result_ref;
24938 }
24939 wxPyEndAllowThreads(__tstate);
24940 if (PyErr_Occurred()) SWIG_fail;
24941 }
24942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24943 return resultobj;
24944 fail:
24945 return NULL;
24946 }
24947
24948
24949 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24950 PyObject *resultobj = 0;
24951 wxDateTime *arg1 = (wxDateTime *) 0 ;
24952 bool arg2 = (bool) false ;
24953 wxDateTime result;
24954 void *argp1 = 0 ;
24955 int res1 = 0 ;
24956 bool val2 ;
24957 int ecode2 = 0 ;
24958 PyObject * obj0 = 0 ;
24959 PyObject * obj1 = 0 ;
24960 char * kwnames[] = {
24961 (char *) "self",(char *) "noDST", NULL
24962 };
24963
24964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24966 if (!SWIG_IsOK(res1)) {
24967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24968 }
24969 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24970 if (obj1) {
24971 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24972 if (!SWIG_IsOK(ecode2)) {
24973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24974 }
24975 arg2 = static_cast< bool >(val2);
24976 }
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24984 return resultobj;
24985 fail:
24986 return NULL;
24987 }
24988
24989
24990 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24991 PyObject *resultobj = 0;
24992 wxDateTime *arg1 = (wxDateTime *) 0 ;
24993 bool arg2 = (bool) false ;
24994 wxDateTime *result = 0 ;
24995 void *argp1 = 0 ;
24996 int res1 = 0 ;
24997 bool val2 ;
24998 int ecode2 = 0 ;
24999 PyObject * obj0 = 0 ;
25000 PyObject * obj1 = 0 ;
25001 char * kwnames[] = {
25002 (char *) "self",(char *) "noDST", NULL
25003 };
25004
25005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
25006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25007 if (!SWIG_IsOK(res1)) {
25008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
25009 }
25010 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25011 if (obj1) {
25012 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25013 if (!SWIG_IsOK(ecode2)) {
25014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
25015 }
25016 arg2 = static_cast< bool >(val2);
25017 }
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 {
25021 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
25022 result = (wxDateTime *) &_result_ref;
25023 }
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25028 return resultobj;
25029 fail:
25030 return NULL;
25031 }
25032
25033
25034 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25035 PyObject *resultobj = 0;
25036 wxDateTime *arg1 = (wxDateTime *) 0 ;
25037 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25038 int result;
25039 void *argp1 = 0 ;
25040 int res1 = 0 ;
25041 int val2 ;
25042 int ecode2 = 0 ;
25043 PyObject * obj0 = 0 ;
25044 PyObject * obj1 = 0 ;
25045 char * kwnames[] = {
25046 (char *) "self",(char *) "country", NULL
25047 };
25048
25049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
25050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25051 if (!SWIG_IsOK(res1)) {
25052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
25053 }
25054 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25055 if (obj1) {
25056 ecode2 = SWIG_AsVal_int(obj1, &val2);
25057 if (!SWIG_IsOK(ecode2)) {
25058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25059 }
25060 arg2 = static_cast< wxDateTime::Country >(val2);
25061 }
25062 {
25063 PyThreadState* __tstate = wxPyBeginAllowThreads();
25064 result = (int)(arg1)->IsDST(arg2);
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 resultobj = SWIG_From_int(static_cast< int >(result));
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25076 PyObject *resultobj = 0;
25077 wxDateTime *arg1 = (wxDateTime *) 0 ;
25078 bool result;
25079 void *argp1 = 0 ;
25080 int res1 = 0 ;
25081 PyObject *swig_obj[1] ;
25082
25083 if (!args) SWIG_fail;
25084 swig_obj[0] = args;
25085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25086 if (!SWIG_IsOK(res1)) {
25087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25088 }
25089 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 result = (bool)((wxDateTime const *)arg1)->IsValid();
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 {
25097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25098 }
25099 return resultobj;
25100 fail:
25101 return NULL;
25102 }
25103
25104
25105 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25106 PyObject *resultobj = 0;
25107 wxDateTime *arg1 = (wxDateTime *) 0 ;
25108 time_t result;
25109 void *argp1 = 0 ;
25110 int res1 = 0 ;
25111 PyObject *swig_obj[1] ;
25112
25113 if (!args) SWIG_fail;
25114 swig_obj[0] = args;
25115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25116 if (!SWIG_IsOK(res1)) {
25117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25118 }
25119 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25120 {
25121 PyThreadState* __tstate = wxPyBeginAllowThreads();
25122 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
25123 wxPyEndAllowThreads(__tstate);
25124 if (PyErr_Occurred()) SWIG_fail;
25125 }
25126 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25134 PyObject *resultobj = 0;
25135 wxDateTime *arg1 = (wxDateTime *) 0 ;
25136 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25137 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25138 int result;
25139 void *argp1 = 0 ;
25140 int res1 = 0 ;
25141 bool temp2 = false ;
25142 PyObject * obj0 = 0 ;
25143 PyObject * obj1 = 0 ;
25144 char * kwnames[] = {
25145 (char *) "self",(char *) "tz", NULL
25146 };
25147
25148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
25149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25150 if (!SWIG_IsOK(res1)) {
25151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25152 }
25153 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25154 if (obj1) {
25155 {
25156 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25157 temp2 = true;
25158 }
25159 }
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
25163 wxPyEndAllowThreads(__tstate);
25164 if (PyErr_Occurred()) SWIG_fail;
25165 }
25166 resultobj = SWIG_From_int(static_cast< int >(result));
25167 {
25168 if (temp2) delete arg2;
25169 }
25170 return resultobj;
25171 fail:
25172 {
25173 if (temp2) delete arg2;
25174 }
25175 return NULL;
25176 }
25177
25178
25179 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25180 PyObject *resultobj = 0;
25181 wxDateTime *arg1 = (wxDateTime *) 0 ;
25182 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25183 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25184 wxDateTime::Month result;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 bool temp2 = false ;
25188 PyObject * obj0 = 0 ;
25189 PyObject * obj1 = 0 ;
25190 char * kwnames[] = {
25191 (char *) "self",(char *) "tz", NULL
25192 };
25193
25194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
25195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25196 if (!SWIG_IsOK(res1)) {
25197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25198 }
25199 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25200 if (obj1) {
25201 {
25202 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25203 temp2 = true;
25204 }
25205 }
25206 {
25207 PyThreadState* __tstate = wxPyBeginAllowThreads();
25208 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25209 wxPyEndAllowThreads(__tstate);
25210 if (PyErr_Occurred()) SWIG_fail;
25211 }
25212 resultobj = SWIG_From_int(static_cast< int >(result));
25213 {
25214 if (temp2) delete arg2;
25215 }
25216 return resultobj;
25217 fail:
25218 {
25219 if (temp2) delete arg2;
25220 }
25221 return NULL;
25222 }
25223
25224
25225 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25226 PyObject *resultobj = 0;
25227 wxDateTime *arg1 = (wxDateTime *) 0 ;
25228 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25229 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25230 int result;
25231 void *argp1 = 0 ;
25232 int res1 = 0 ;
25233 bool temp2 = false ;
25234 PyObject * obj0 = 0 ;
25235 PyObject * obj1 = 0 ;
25236 char * kwnames[] = {
25237 (char *) "self",(char *) "tz", NULL
25238 };
25239
25240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25242 if (!SWIG_IsOK(res1)) {
25243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25244 }
25245 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25246 if (obj1) {
25247 {
25248 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25249 temp2 = true;
25250 }
25251 }
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 resultobj = SWIG_From_int(static_cast< int >(result));
25259 {
25260 if (temp2) delete arg2;
25261 }
25262 return resultobj;
25263 fail:
25264 {
25265 if (temp2) delete arg2;
25266 }
25267 return NULL;
25268 }
25269
25270
25271 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25272 PyObject *resultobj = 0;
25273 wxDateTime *arg1 = (wxDateTime *) 0 ;
25274 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25275 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25276 wxDateTime::WeekDay result;
25277 void *argp1 = 0 ;
25278 int res1 = 0 ;
25279 bool temp2 = false ;
25280 PyObject * obj0 = 0 ;
25281 PyObject * obj1 = 0 ;
25282 char * kwnames[] = {
25283 (char *) "self",(char *) "tz", NULL
25284 };
25285
25286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25288 if (!SWIG_IsOK(res1)) {
25289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25290 }
25291 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25292 if (obj1) {
25293 {
25294 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25295 temp2 = true;
25296 }
25297 }
25298 {
25299 PyThreadState* __tstate = wxPyBeginAllowThreads();
25300 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25301 wxPyEndAllowThreads(__tstate);
25302 if (PyErr_Occurred()) SWIG_fail;
25303 }
25304 resultobj = SWIG_From_int(static_cast< int >(result));
25305 {
25306 if (temp2) delete arg2;
25307 }
25308 return resultobj;
25309 fail:
25310 {
25311 if (temp2) delete arg2;
25312 }
25313 return NULL;
25314 }
25315
25316
25317 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25318 PyObject *resultobj = 0;
25319 wxDateTime *arg1 = (wxDateTime *) 0 ;
25320 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25321 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25322 int result;
25323 void *argp1 = 0 ;
25324 int res1 = 0 ;
25325 bool temp2 = false ;
25326 PyObject * obj0 = 0 ;
25327 PyObject * obj1 = 0 ;
25328 char * kwnames[] = {
25329 (char *) "self",(char *) "tz", NULL
25330 };
25331
25332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25334 if (!SWIG_IsOK(res1)) {
25335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25336 }
25337 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25338 if (obj1) {
25339 {
25340 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25341 temp2 = true;
25342 }
25343 }
25344 {
25345 PyThreadState* __tstate = wxPyBeginAllowThreads();
25346 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25347 wxPyEndAllowThreads(__tstate);
25348 if (PyErr_Occurred()) SWIG_fail;
25349 }
25350 resultobj = SWIG_From_int(static_cast< int >(result));
25351 {
25352 if (temp2) delete arg2;
25353 }
25354 return resultobj;
25355 fail:
25356 {
25357 if (temp2) delete arg2;
25358 }
25359 return NULL;
25360 }
25361
25362
25363 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25364 PyObject *resultobj = 0;
25365 wxDateTime *arg1 = (wxDateTime *) 0 ;
25366 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25367 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25368 int result;
25369 void *argp1 = 0 ;
25370 int res1 = 0 ;
25371 bool temp2 = false ;
25372 PyObject * obj0 = 0 ;
25373 PyObject * obj1 = 0 ;
25374 char * kwnames[] = {
25375 (char *) "self",(char *) "tz", NULL
25376 };
25377
25378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25380 if (!SWIG_IsOK(res1)) {
25381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25382 }
25383 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25384 if (obj1) {
25385 {
25386 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25387 temp2 = true;
25388 }
25389 }
25390 {
25391 PyThreadState* __tstate = wxPyBeginAllowThreads();
25392 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25393 wxPyEndAllowThreads(__tstate);
25394 if (PyErr_Occurred()) SWIG_fail;
25395 }
25396 resultobj = SWIG_From_int(static_cast< int >(result));
25397 {
25398 if (temp2) delete arg2;
25399 }
25400 return resultobj;
25401 fail:
25402 {
25403 if (temp2) delete arg2;
25404 }
25405 return NULL;
25406 }
25407
25408
25409 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25410 PyObject *resultobj = 0;
25411 wxDateTime *arg1 = (wxDateTime *) 0 ;
25412 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25413 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25414 int result;
25415 void *argp1 = 0 ;
25416 int res1 = 0 ;
25417 bool temp2 = false ;
25418 PyObject * obj0 = 0 ;
25419 PyObject * obj1 = 0 ;
25420 char * kwnames[] = {
25421 (char *) "self",(char *) "tz", NULL
25422 };
25423
25424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25426 if (!SWIG_IsOK(res1)) {
25427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25428 }
25429 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25430 if (obj1) {
25431 {
25432 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25433 temp2 = true;
25434 }
25435 }
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_From_int(static_cast< int >(result));
25443 {
25444 if (temp2) delete arg2;
25445 }
25446 return resultobj;
25447 fail:
25448 {
25449 if (temp2) delete arg2;
25450 }
25451 return NULL;
25452 }
25453
25454
25455 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25456 PyObject *resultobj = 0;
25457 wxDateTime *arg1 = (wxDateTime *) 0 ;
25458 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25459 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25460 int result;
25461 void *argp1 = 0 ;
25462 int res1 = 0 ;
25463 bool temp2 = false ;
25464 PyObject * obj0 = 0 ;
25465 PyObject * obj1 = 0 ;
25466 char * kwnames[] = {
25467 (char *) "self",(char *) "tz", NULL
25468 };
25469
25470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25472 if (!SWIG_IsOK(res1)) {
25473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25474 }
25475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25476 if (obj1) {
25477 {
25478 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25479 temp2 = true;
25480 }
25481 }
25482 {
25483 PyThreadState* __tstate = wxPyBeginAllowThreads();
25484 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25485 wxPyEndAllowThreads(__tstate);
25486 if (PyErr_Occurred()) SWIG_fail;
25487 }
25488 resultobj = SWIG_From_int(static_cast< int >(result));
25489 {
25490 if (temp2) delete arg2;
25491 }
25492 return resultobj;
25493 fail:
25494 {
25495 if (temp2) delete arg2;
25496 }
25497 return NULL;
25498 }
25499
25500
25501 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25502 PyObject *resultobj = 0;
25503 wxDateTime *arg1 = (wxDateTime *) 0 ;
25504 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25505 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25506 int result;
25507 void *argp1 = 0 ;
25508 int res1 = 0 ;
25509 bool temp2 = false ;
25510 PyObject * obj0 = 0 ;
25511 PyObject * obj1 = 0 ;
25512 char * kwnames[] = {
25513 (char *) "self",(char *) "tz", NULL
25514 };
25515
25516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25518 if (!SWIG_IsOK(res1)) {
25519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25520 }
25521 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25522 if (obj1) {
25523 {
25524 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25525 temp2 = true;
25526 }
25527 }
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 resultobj = SWIG_From_int(static_cast< int >(result));
25535 {
25536 if (temp2) delete arg2;
25537 }
25538 return resultobj;
25539 fail:
25540 {
25541 if (temp2) delete arg2;
25542 }
25543 return NULL;
25544 }
25545
25546
25547 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25548 PyObject *resultobj = 0;
25549 wxDateTime *arg1 = (wxDateTime *) 0 ;
25550 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25551 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25552 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25553 int result;
25554 void *argp1 = 0 ;
25555 int res1 = 0 ;
25556 int val2 ;
25557 int ecode2 = 0 ;
25558 bool temp3 = false ;
25559 PyObject * obj0 = 0 ;
25560 PyObject * obj1 = 0 ;
25561 PyObject * obj2 = 0 ;
25562 char * kwnames[] = {
25563 (char *) "self",(char *) "flags",(char *) "tz", NULL
25564 };
25565
25566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25568 if (!SWIG_IsOK(res1)) {
25569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25570 }
25571 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25572 if (obj1) {
25573 ecode2 = SWIG_AsVal_int(obj1, &val2);
25574 if (!SWIG_IsOK(ecode2)) {
25575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25576 }
25577 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25578 }
25579 if (obj2) {
25580 {
25581 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25582 temp3 = true;
25583 }
25584 }
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25588 wxPyEndAllowThreads(__tstate);
25589 if (PyErr_Occurred()) SWIG_fail;
25590 }
25591 resultobj = SWIG_From_int(static_cast< int >(result));
25592 {
25593 if (temp3) delete arg3;
25594 }
25595 return resultobj;
25596 fail:
25597 {
25598 if (temp3) delete arg3;
25599 }
25600 return NULL;
25601 }
25602
25603
25604 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25605 PyObject *resultobj = 0;
25606 wxDateTime *arg1 = (wxDateTime *) 0 ;
25607 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25608 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25609 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25610 int result;
25611 void *argp1 = 0 ;
25612 int res1 = 0 ;
25613 int val2 ;
25614 int ecode2 = 0 ;
25615 bool temp3 = false ;
25616 PyObject * obj0 = 0 ;
25617 PyObject * obj1 = 0 ;
25618 PyObject * obj2 = 0 ;
25619 char * kwnames[] = {
25620 (char *) "self",(char *) "flags",(char *) "tz", NULL
25621 };
25622
25623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25625 if (!SWIG_IsOK(res1)) {
25626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25627 }
25628 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25629 if (obj1) {
25630 ecode2 = SWIG_AsVal_int(obj1, &val2);
25631 if (!SWIG_IsOK(ecode2)) {
25632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25633 }
25634 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25635 }
25636 if (obj2) {
25637 {
25638 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25639 temp3 = true;
25640 }
25641 }
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 resultobj = SWIG_From_int(static_cast< int >(result));
25649 {
25650 if (temp3) delete arg3;
25651 }
25652 return resultobj;
25653 fail:
25654 {
25655 if (temp3) delete arg3;
25656 }
25657 return NULL;
25658 }
25659
25660
25661 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25662 PyObject *resultobj = 0;
25663 wxDateTime *arg1 = (wxDateTime *) 0 ;
25664 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25665 bool result;
25666 void *argp1 = 0 ;
25667 int res1 = 0 ;
25668 int val2 ;
25669 int ecode2 = 0 ;
25670 PyObject * obj0 = 0 ;
25671 PyObject * obj1 = 0 ;
25672 char * kwnames[] = {
25673 (char *) "self",(char *) "country", NULL
25674 };
25675
25676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25678 if (!SWIG_IsOK(res1)) {
25679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25680 }
25681 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25682 if (obj1) {
25683 ecode2 = SWIG_AsVal_int(obj1, &val2);
25684 if (!SWIG_IsOK(ecode2)) {
25685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25686 }
25687 arg2 = static_cast< wxDateTime::Country >(val2);
25688 }
25689 {
25690 PyThreadState* __tstate = wxPyBeginAllowThreads();
25691 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25692 wxPyEndAllowThreads(__tstate);
25693 if (PyErr_Occurred()) SWIG_fail;
25694 }
25695 {
25696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25697 }
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25705 PyObject *resultobj = 0;
25706 wxDateTime *arg1 = (wxDateTime *) 0 ;
25707 wxDateTime *arg2 = 0 ;
25708 bool result;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 void *argp2 = 0 ;
25712 int res2 = 0 ;
25713 PyObject * obj0 = 0 ;
25714 PyObject * obj1 = 0 ;
25715 char * kwnames[] = {
25716 (char *) "self",(char *) "datetime", NULL
25717 };
25718
25719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25721 if (!SWIG_IsOK(res1)) {
25722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25723 }
25724 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25725 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25726 if (!SWIG_IsOK(res2)) {
25727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25728 }
25729 if (!argp2) {
25730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25731 }
25732 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25736 wxPyEndAllowThreads(__tstate);
25737 if (PyErr_Occurred()) SWIG_fail;
25738 }
25739 {
25740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25741 }
25742 return resultobj;
25743 fail:
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25749 PyObject *resultobj = 0;
25750 wxDateTime *arg1 = (wxDateTime *) 0 ;
25751 wxDateTime *arg2 = 0 ;
25752 bool result;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 void *argp2 = 0 ;
25756 int res2 = 0 ;
25757 PyObject * obj0 = 0 ;
25758 PyObject * obj1 = 0 ;
25759 char * kwnames[] = {
25760 (char *) "self",(char *) "datetime", NULL
25761 };
25762
25763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25765 if (!SWIG_IsOK(res1)) {
25766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25767 }
25768 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25769 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25770 if (!SWIG_IsOK(res2)) {
25771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25772 }
25773 if (!argp2) {
25774 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25775 }
25776 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25777 {
25778 PyThreadState* __tstate = wxPyBeginAllowThreads();
25779 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 {
25784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25785 }
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj = 0;
25794 wxDateTime *arg1 = (wxDateTime *) 0 ;
25795 wxDateTime *arg2 = 0 ;
25796 bool result;
25797 void *argp1 = 0 ;
25798 int res1 = 0 ;
25799 void *argp2 = 0 ;
25800 int res2 = 0 ;
25801 PyObject * obj0 = 0 ;
25802 PyObject * obj1 = 0 ;
25803 char * kwnames[] = {
25804 (char *) "self",(char *) "datetime", NULL
25805 };
25806
25807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25809 if (!SWIG_IsOK(res1)) {
25810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25811 }
25812 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25813 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25814 if (!SWIG_IsOK(res2)) {
25815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25816 }
25817 if (!argp2) {
25818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25819 }
25820 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25821 {
25822 PyThreadState* __tstate = wxPyBeginAllowThreads();
25823 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25824 wxPyEndAllowThreads(__tstate);
25825 if (PyErr_Occurred()) SWIG_fail;
25826 }
25827 {
25828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25829 }
25830 return resultobj;
25831 fail:
25832 return NULL;
25833 }
25834
25835
25836 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25837 PyObject *resultobj = 0;
25838 wxDateTime *arg1 = (wxDateTime *) 0 ;
25839 wxDateTime *arg2 = 0 ;
25840 wxDateTime *arg3 = 0 ;
25841 bool result;
25842 void *argp1 = 0 ;
25843 int res1 = 0 ;
25844 void *argp2 = 0 ;
25845 int res2 = 0 ;
25846 void *argp3 = 0 ;
25847 int res3 = 0 ;
25848 PyObject * obj0 = 0 ;
25849 PyObject * obj1 = 0 ;
25850 PyObject * obj2 = 0 ;
25851 char * kwnames[] = {
25852 (char *) "self",(char *) "t1",(char *) "t2", NULL
25853 };
25854
25855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25857 if (!SWIG_IsOK(res1)) {
25858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25859 }
25860 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25862 if (!SWIG_IsOK(res2)) {
25863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25864 }
25865 if (!argp2) {
25866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25867 }
25868 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25869 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25870 if (!SWIG_IsOK(res3)) {
25871 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25872 }
25873 if (!argp3) {
25874 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25875 }
25876 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 {
25884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25885 }
25886 return resultobj;
25887 fail:
25888 return NULL;
25889 }
25890
25891
25892 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25893 PyObject *resultobj = 0;
25894 wxDateTime *arg1 = (wxDateTime *) 0 ;
25895 wxDateTime *arg2 = 0 ;
25896 wxDateTime *arg3 = 0 ;
25897 bool result;
25898 void *argp1 = 0 ;
25899 int res1 = 0 ;
25900 void *argp2 = 0 ;
25901 int res2 = 0 ;
25902 void *argp3 = 0 ;
25903 int res3 = 0 ;
25904 PyObject * obj0 = 0 ;
25905 PyObject * obj1 = 0 ;
25906 PyObject * obj2 = 0 ;
25907 char * kwnames[] = {
25908 (char *) "self",(char *) "t1",(char *) "t2", NULL
25909 };
25910
25911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25913 if (!SWIG_IsOK(res1)) {
25914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25915 }
25916 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25917 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25918 if (!SWIG_IsOK(res2)) {
25919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25920 }
25921 if (!argp2) {
25922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25923 }
25924 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25925 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25926 if (!SWIG_IsOK(res3)) {
25927 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25928 }
25929 if (!argp3) {
25930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25931 }
25932 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 {
25940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25941 }
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj = 0;
25950 wxDateTime *arg1 = (wxDateTime *) 0 ;
25951 wxDateTime *arg2 = 0 ;
25952 bool result;
25953 void *argp1 = 0 ;
25954 int res1 = 0 ;
25955 void *argp2 = 0 ;
25956 int res2 = 0 ;
25957 PyObject * obj0 = 0 ;
25958 PyObject * obj1 = 0 ;
25959 char * kwnames[] = {
25960 (char *) "self",(char *) "dt", NULL
25961 };
25962
25963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25965 if (!SWIG_IsOK(res1)) {
25966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25967 }
25968 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25969 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25970 if (!SWIG_IsOK(res2)) {
25971 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25972 }
25973 if (!argp2) {
25974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25975 }
25976 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25977 {
25978 PyThreadState* __tstate = wxPyBeginAllowThreads();
25979 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25980 wxPyEndAllowThreads(__tstate);
25981 if (PyErr_Occurred()) SWIG_fail;
25982 }
25983 {
25984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25985 }
25986 return resultobj;
25987 fail:
25988 return NULL;
25989 }
25990
25991
25992 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25993 PyObject *resultobj = 0;
25994 wxDateTime *arg1 = (wxDateTime *) 0 ;
25995 wxDateTime *arg2 = 0 ;
25996 bool result;
25997 void *argp1 = 0 ;
25998 int res1 = 0 ;
25999 void *argp2 = 0 ;
26000 int res2 = 0 ;
26001 PyObject * obj0 = 0 ;
26002 PyObject * obj1 = 0 ;
26003 char * kwnames[] = {
26004 (char *) "self",(char *) "dt", NULL
26005 };
26006
26007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
26008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26009 if (!SWIG_IsOK(res1)) {
26010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26011 }
26012 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26013 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26014 if (!SWIG_IsOK(res2)) {
26015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26016 }
26017 if (!argp2) {
26018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26019 }
26020 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26021 {
26022 PyThreadState* __tstate = wxPyBeginAllowThreads();
26023 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
26024 wxPyEndAllowThreads(__tstate);
26025 if (PyErr_Occurred()) SWIG_fail;
26026 }
26027 {
26028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26029 }
26030 return resultobj;
26031 fail:
26032 return NULL;
26033 }
26034
26035
26036 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26037 PyObject *resultobj = 0;
26038 wxDateTime *arg1 = (wxDateTime *) 0 ;
26039 wxDateTime *arg2 = 0 ;
26040 wxTimeSpan *arg3 = 0 ;
26041 bool result;
26042 void *argp1 = 0 ;
26043 int res1 = 0 ;
26044 void *argp2 = 0 ;
26045 int res2 = 0 ;
26046 void *argp3 = 0 ;
26047 int res3 = 0 ;
26048 PyObject * obj0 = 0 ;
26049 PyObject * obj1 = 0 ;
26050 PyObject * obj2 = 0 ;
26051 char * kwnames[] = {
26052 (char *) "self",(char *) "dt",(char *) "ts", NULL
26053 };
26054
26055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26057 if (!SWIG_IsOK(res1)) {
26058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26059 }
26060 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26062 if (!SWIG_IsOK(res2)) {
26063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26064 }
26065 if (!argp2) {
26066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26067 }
26068 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26069 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26070 if (!SWIG_IsOK(res3)) {
26071 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26072 }
26073 if (!argp3) {
26074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
26075 }
26076 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
26080 wxPyEndAllowThreads(__tstate);
26081 if (PyErr_Occurred()) SWIG_fail;
26082 }
26083 {
26084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26085 }
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj = 0;
26094 wxDateTime *arg1 = (wxDateTime *) 0 ;
26095 wxTimeSpan *arg2 = 0 ;
26096 wxDateTime *result = 0 ;
26097 void *argp1 = 0 ;
26098 int res1 = 0 ;
26099 void *argp2 = 0 ;
26100 int res2 = 0 ;
26101 PyObject * obj0 = 0 ;
26102 PyObject * obj1 = 0 ;
26103 char * kwnames[] = {
26104 (char *) "self",(char *) "diff", NULL
26105 };
26106
26107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
26108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26109 if (!SWIG_IsOK(res1)) {
26110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26111 }
26112 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26114 if (!SWIG_IsOK(res2)) {
26115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26116 }
26117 if (!argp2) {
26118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26119 }
26120 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26121 {
26122 PyThreadState* __tstate = wxPyBeginAllowThreads();
26123 {
26124 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
26125 result = (wxDateTime *) &_result_ref;
26126 }
26127 wxPyEndAllowThreads(__tstate);
26128 if (PyErr_Occurred()) SWIG_fail;
26129 }
26130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26131 return resultobj;
26132 fail:
26133 return NULL;
26134 }
26135
26136
26137 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26138 PyObject *resultobj = 0;
26139 wxDateTime *arg1 = (wxDateTime *) 0 ;
26140 wxDateSpan *arg2 = 0 ;
26141 wxDateTime *result = 0 ;
26142 void *argp1 = 0 ;
26143 int res1 = 0 ;
26144 void *argp2 = 0 ;
26145 int res2 = 0 ;
26146 PyObject * obj0 = 0 ;
26147 PyObject * obj1 = 0 ;
26148 char * kwnames[] = {
26149 (char *) "self",(char *) "diff", NULL
26150 };
26151
26152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
26153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26154 if (!SWIG_IsOK(res1)) {
26155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26156 }
26157 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26158 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26159 if (!SWIG_IsOK(res2)) {
26160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26161 }
26162 if (!argp2) {
26163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26164 }
26165 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 {
26169 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
26170 result = (wxDateTime *) &_result_ref;
26171 }
26172 wxPyEndAllowThreads(__tstate);
26173 if (PyErr_Occurred()) SWIG_fail;
26174 }
26175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26183 PyObject *resultobj = 0;
26184 wxDateTime *arg1 = (wxDateTime *) 0 ;
26185 wxTimeSpan *arg2 = 0 ;
26186 wxDateTime *result = 0 ;
26187 void *argp1 = 0 ;
26188 int res1 = 0 ;
26189 void *argp2 = 0 ;
26190 int res2 = 0 ;
26191 PyObject * obj0 = 0 ;
26192 PyObject * obj1 = 0 ;
26193 char * kwnames[] = {
26194 (char *) "self",(char *) "diff", NULL
26195 };
26196
26197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
26198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26199 if (!SWIG_IsOK(res1)) {
26200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26201 }
26202 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26203 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26204 if (!SWIG_IsOK(res2)) {
26205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26206 }
26207 if (!argp2) {
26208 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26209 }
26210 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 {
26214 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26215 result = (wxDateTime *) &_result_ref;
26216 }
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26228 PyObject *resultobj = 0;
26229 wxDateTime *arg1 = (wxDateTime *) 0 ;
26230 wxDateSpan *arg2 = 0 ;
26231 wxDateTime *result = 0 ;
26232 void *argp1 = 0 ;
26233 int res1 = 0 ;
26234 void *argp2 = 0 ;
26235 int res2 = 0 ;
26236 PyObject * obj0 = 0 ;
26237 PyObject * obj1 = 0 ;
26238 char * kwnames[] = {
26239 (char *) "self",(char *) "diff", NULL
26240 };
26241
26242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26244 if (!SWIG_IsOK(res1)) {
26245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26246 }
26247 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26248 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26249 if (!SWIG_IsOK(res2)) {
26250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26251 }
26252 if (!argp2) {
26253 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26254 }
26255 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26256 {
26257 PyThreadState* __tstate = wxPyBeginAllowThreads();
26258 {
26259 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26260 result = (wxDateTime *) &_result_ref;
26261 }
26262 wxPyEndAllowThreads(__tstate);
26263 if (PyErr_Occurred()) SWIG_fail;
26264 }
26265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26266 return resultobj;
26267 fail:
26268 return NULL;
26269 }
26270
26271
26272 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26273 PyObject *resultobj = 0;
26274 wxDateTime *arg1 = (wxDateTime *) 0 ;
26275 wxDateTime *arg2 = 0 ;
26276 wxTimeSpan result;
26277 void *argp1 = 0 ;
26278 int res1 = 0 ;
26279 void *argp2 = 0 ;
26280 int res2 = 0 ;
26281 PyObject * obj0 = 0 ;
26282 PyObject * obj1 = 0 ;
26283 char * kwnames[] = {
26284 (char *) "self",(char *) "dt", NULL
26285 };
26286
26287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26289 if (!SWIG_IsOK(res1)) {
26290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26291 }
26292 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26293 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26294 if (!SWIG_IsOK(res2)) {
26295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26296 }
26297 if (!argp2) {
26298 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26299 }
26300 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26308 return resultobj;
26309 fail:
26310 return NULL;
26311 }
26312
26313
26314 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26315 PyObject *resultobj = 0;
26316 wxDateTime *arg1 = (wxDateTime *) 0 ;
26317 wxTimeSpan *arg2 = 0 ;
26318 wxDateTime *result = 0 ;
26319 void *argp1 = 0 ;
26320 int res1 = 0 ;
26321 void *argp2 = 0 ;
26322 int res2 = 0 ;
26323
26324 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26326 if (!SWIG_IsOK(res1)) {
26327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26328 }
26329 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26330 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26331 if (!SWIG_IsOK(res2)) {
26332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26333 }
26334 if (!argp2) {
26335 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26336 }
26337 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 {
26341 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26342 result = (wxDateTime *) &_result_ref;
26343 }
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26355 PyObject *resultobj = 0;
26356 wxDateTime *arg1 = (wxDateTime *) 0 ;
26357 wxDateSpan *arg2 = 0 ;
26358 wxDateTime *result = 0 ;
26359 void *argp1 = 0 ;
26360 int res1 = 0 ;
26361 void *argp2 = 0 ;
26362 int res2 = 0 ;
26363
26364 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26366 if (!SWIG_IsOK(res1)) {
26367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26368 }
26369 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26370 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26371 if (!SWIG_IsOK(res2)) {
26372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26373 }
26374 if (!argp2) {
26375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26376 }
26377 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 {
26381 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26382 result = (wxDateTime *) &_result_ref;
26383 }
26384 wxPyEndAllowThreads(__tstate);
26385 if (PyErr_Occurred()) SWIG_fail;
26386 }
26387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26388 return resultobj;
26389 fail:
26390 return NULL;
26391 }
26392
26393
26394 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26395 int argc;
26396 PyObject *argv[3];
26397
26398 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26399 --argc;
26400 if (argc == 2) {
26401 int _v = 0;
26402 {
26403 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26404 _v = SWIG_CheckState(res);
26405 }
26406 if (!_v) goto check_1;
26407 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26408 }
26409 check_1:
26410
26411 if (argc == 2) {
26412 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26413 }
26414
26415 fail:
26416 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26422 PyObject *resultobj = 0;
26423 wxDateTime *arg1 = (wxDateTime *) 0 ;
26424 wxTimeSpan *arg2 = 0 ;
26425 wxDateTime *result = 0 ;
26426 void *argp1 = 0 ;
26427 int res1 = 0 ;
26428 void *argp2 = 0 ;
26429 int res2 = 0 ;
26430
26431 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26433 if (!SWIG_IsOK(res1)) {
26434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26435 }
26436 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26437 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26438 if (!SWIG_IsOK(res2)) {
26439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26440 }
26441 if (!argp2) {
26442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26443 }
26444 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26445 {
26446 PyThreadState* __tstate = wxPyBeginAllowThreads();
26447 {
26448 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26449 result = (wxDateTime *) &_result_ref;
26450 }
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26455 return resultobj;
26456 fail:
26457 return NULL;
26458 }
26459
26460
26461 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26462 PyObject *resultobj = 0;
26463 wxDateTime *arg1 = (wxDateTime *) 0 ;
26464 wxDateSpan *arg2 = 0 ;
26465 wxDateTime *result = 0 ;
26466 void *argp1 = 0 ;
26467 int res1 = 0 ;
26468 void *argp2 = 0 ;
26469 int res2 = 0 ;
26470
26471 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26473 if (!SWIG_IsOK(res1)) {
26474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26475 }
26476 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26477 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26478 if (!SWIG_IsOK(res2)) {
26479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26480 }
26481 if (!argp2) {
26482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26483 }
26484 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 {
26488 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26489 result = (wxDateTime *) &_result_ref;
26490 }
26491 wxPyEndAllowThreads(__tstate);
26492 if (PyErr_Occurred()) SWIG_fail;
26493 }
26494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26495 return resultobj;
26496 fail:
26497 return NULL;
26498 }
26499
26500
26501 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26502 int argc;
26503 PyObject *argv[3];
26504
26505 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26506 --argc;
26507 if (argc == 2) {
26508 int _v = 0;
26509 {
26510 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26511 _v = SWIG_CheckState(res);
26512 }
26513 if (!_v) goto check_1;
26514 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26515 }
26516 check_1:
26517
26518 if (argc == 2) {
26519 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26520 }
26521
26522 fail:
26523 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26524 return NULL;
26525 }
26526
26527
26528 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26529 PyObject *resultobj = 0;
26530 wxDateTime *arg1 = (wxDateTime *) 0 ;
26531 wxTimeSpan *arg2 = 0 ;
26532 wxDateTime result;
26533 void *argp1 = 0 ;
26534 int res1 = 0 ;
26535 void *argp2 = 0 ;
26536 int res2 = 0 ;
26537
26538 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26540 if (!SWIG_IsOK(res1)) {
26541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26542 }
26543 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26544 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26545 if (!SWIG_IsOK(res2)) {
26546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26547 }
26548 if (!argp2) {
26549 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26550 }
26551 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26566 PyObject *resultobj = 0;
26567 wxDateTime *arg1 = (wxDateTime *) 0 ;
26568 wxDateSpan *arg2 = 0 ;
26569 wxDateTime result;
26570 void *argp1 = 0 ;
26571 int res1 = 0 ;
26572 void *argp2 = 0 ;
26573 int res2 = 0 ;
26574
26575 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26577 if (!SWIG_IsOK(res1)) {
26578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26579 }
26580 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26581 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26582 if (!SWIG_IsOK(res2)) {
26583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26584 }
26585 if (!argp2) {
26586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26587 }
26588 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26596 return resultobj;
26597 fail:
26598 return NULL;
26599 }
26600
26601
26602 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26603 int argc;
26604 PyObject *argv[3];
26605
26606 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26607 --argc;
26608 if (argc == 2) {
26609 int _v = 0;
26610 {
26611 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26612 _v = SWIG_CheckState(res);
26613 }
26614 if (!_v) goto check_1;
26615 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26616 }
26617 check_1:
26618
26619 if (argc == 2) {
26620 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26621 }
26622
26623 fail:
26624 Py_INCREF(Py_NotImplemented);
26625 return Py_NotImplemented;
26626 }
26627
26628
26629 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26630 PyObject *resultobj = 0;
26631 wxDateTime *arg1 = (wxDateTime *) 0 ;
26632 wxDateTime *arg2 = 0 ;
26633 wxTimeSpan result;
26634 void *argp1 = 0 ;
26635 int res1 = 0 ;
26636 void *argp2 = 0 ;
26637 int res2 = 0 ;
26638
26639 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26641 if (!SWIG_IsOK(res1)) {
26642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26643 }
26644 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26645 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26646 if (!SWIG_IsOK(res2)) {
26647 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26648 }
26649 if (!argp2) {
26650 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26651 }
26652 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26653 {
26654 PyThreadState* __tstate = wxPyBeginAllowThreads();
26655 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26656 wxPyEndAllowThreads(__tstate);
26657 if (PyErr_Occurred()) SWIG_fail;
26658 }
26659 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26660 return resultobj;
26661 fail:
26662 return NULL;
26663 }
26664
26665
26666 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26667 PyObject *resultobj = 0;
26668 wxDateTime *arg1 = (wxDateTime *) 0 ;
26669 wxTimeSpan *arg2 = 0 ;
26670 wxDateTime result;
26671 void *argp1 = 0 ;
26672 int res1 = 0 ;
26673 void *argp2 = 0 ;
26674 int res2 = 0 ;
26675
26676 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26678 if (!SWIG_IsOK(res1)) {
26679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26680 }
26681 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26682 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26683 if (!SWIG_IsOK(res2)) {
26684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26685 }
26686 if (!argp2) {
26687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26688 }
26689 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26690 {
26691 PyThreadState* __tstate = wxPyBeginAllowThreads();
26692 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26693 wxPyEndAllowThreads(__tstate);
26694 if (PyErr_Occurred()) SWIG_fail;
26695 }
26696 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26697 return resultobj;
26698 fail:
26699 return NULL;
26700 }
26701
26702
26703 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26704 PyObject *resultobj = 0;
26705 wxDateTime *arg1 = (wxDateTime *) 0 ;
26706 wxDateSpan *arg2 = 0 ;
26707 wxDateTime result;
26708 void *argp1 = 0 ;
26709 int res1 = 0 ;
26710 void *argp2 = 0 ;
26711 int res2 = 0 ;
26712
26713 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26715 if (!SWIG_IsOK(res1)) {
26716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26717 }
26718 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26719 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26720 if (!SWIG_IsOK(res2)) {
26721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26722 }
26723 if (!argp2) {
26724 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26725 }
26726 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26730 wxPyEndAllowThreads(__tstate);
26731 if (PyErr_Occurred()) SWIG_fail;
26732 }
26733 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26734 return resultobj;
26735 fail:
26736 return NULL;
26737 }
26738
26739
26740 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26741 int argc;
26742 PyObject *argv[3];
26743
26744 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26745 --argc;
26746 if (argc == 2) {
26747 int _v = 0;
26748 {
26749 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26750 _v = SWIG_CheckState(res);
26751 }
26752 if (!_v) goto check_1;
26753 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26754 }
26755 check_1:
26756
26757 if (argc == 2) {
26758 int _v = 0;
26759 {
26760 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26761 _v = SWIG_CheckState(res);
26762 }
26763 if (!_v) goto check_2;
26764 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26765 }
26766 check_2:
26767
26768 if (argc == 2) {
26769 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26770 }
26771
26772 fail:
26773 Py_INCREF(Py_NotImplemented);
26774 return Py_NotImplemented;
26775 }
26776
26777
26778 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26779 PyObject *resultobj = 0;
26780 wxDateTime *arg1 = (wxDateTime *) 0 ;
26781 wxDateTime *arg2 = (wxDateTime *) 0 ;
26782 bool result;
26783 void *argp1 = 0 ;
26784 int res1 = 0 ;
26785 void *argp2 = 0 ;
26786 int res2 = 0 ;
26787 PyObject * obj0 = 0 ;
26788 PyObject * obj1 = 0 ;
26789 char * kwnames[] = {
26790 (char *) "self",(char *) "other", NULL
26791 };
26792
26793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26795 if (!SWIG_IsOK(res1)) {
26796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26797 }
26798 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26800 if (!SWIG_IsOK(res2)) {
26801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26802 }
26803 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26804 {
26805 PyThreadState* __tstate = wxPyBeginAllowThreads();
26806 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26807 wxPyEndAllowThreads(__tstate);
26808 if (PyErr_Occurred()) SWIG_fail;
26809 }
26810 {
26811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26812 }
26813 return resultobj;
26814 fail:
26815 return NULL;
26816 }
26817
26818
26819 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26820 PyObject *resultobj = 0;
26821 wxDateTime *arg1 = (wxDateTime *) 0 ;
26822 wxDateTime *arg2 = (wxDateTime *) 0 ;
26823 bool result;
26824 void *argp1 = 0 ;
26825 int res1 = 0 ;
26826 void *argp2 = 0 ;
26827 int res2 = 0 ;
26828 PyObject * obj0 = 0 ;
26829 PyObject * obj1 = 0 ;
26830 char * kwnames[] = {
26831 (char *) "self",(char *) "other", NULL
26832 };
26833
26834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26836 if (!SWIG_IsOK(res1)) {
26837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26838 }
26839 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26840 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26841 if (!SWIG_IsOK(res2)) {
26842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26843 }
26844 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26845 {
26846 PyThreadState* __tstate = wxPyBeginAllowThreads();
26847 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26848 wxPyEndAllowThreads(__tstate);
26849 if (PyErr_Occurred()) SWIG_fail;
26850 }
26851 {
26852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26853 }
26854 return resultobj;
26855 fail:
26856 return NULL;
26857 }
26858
26859
26860 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26861 PyObject *resultobj = 0;
26862 wxDateTime *arg1 = (wxDateTime *) 0 ;
26863 wxDateTime *arg2 = (wxDateTime *) 0 ;
26864 bool result;
26865 void *argp1 = 0 ;
26866 int res1 = 0 ;
26867 void *argp2 = 0 ;
26868 int res2 = 0 ;
26869 PyObject * obj0 = 0 ;
26870 PyObject * obj1 = 0 ;
26871 char * kwnames[] = {
26872 (char *) "self",(char *) "other", NULL
26873 };
26874
26875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26877 if (!SWIG_IsOK(res1)) {
26878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26879 }
26880 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26881 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26882 if (!SWIG_IsOK(res2)) {
26883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26884 }
26885 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 {
26893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26894 }
26895 return resultobj;
26896 fail:
26897 return NULL;
26898 }
26899
26900
26901 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26902 PyObject *resultobj = 0;
26903 wxDateTime *arg1 = (wxDateTime *) 0 ;
26904 wxDateTime *arg2 = (wxDateTime *) 0 ;
26905 bool result;
26906 void *argp1 = 0 ;
26907 int res1 = 0 ;
26908 void *argp2 = 0 ;
26909 int res2 = 0 ;
26910 PyObject * obj0 = 0 ;
26911 PyObject * obj1 = 0 ;
26912 char * kwnames[] = {
26913 (char *) "self",(char *) "other", NULL
26914 };
26915
26916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26918 if (!SWIG_IsOK(res1)) {
26919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26920 }
26921 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26922 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26923 if (!SWIG_IsOK(res2)) {
26924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26925 }
26926 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26930 wxPyEndAllowThreads(__tstate);
26931 if (PyErr_Occurred()) SWIG_fail;
26932 }
26933 {
26934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26935 }
26936 return resultobj;
26937 fail:
26938 return NULL;
26939 }
26940
26941
26942 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26943 PyObject *resultobj = 0;
26944 wxDateTime *arg1 = (wxDateTime *) 0 ;
26945 wxDateTime *arg2 = (wxDateTime *) 0 ;
26946 bool result;
26947 void *argp1 = 0 ;
26948 int res1 = 0 ;
26949 void *argp2 = 0 ;
26950 int res2 = 0 ;
26951 PyObject * obj0 = 0 ;
26952 PyObject * obj1 = 0 ;
26953 char * kwnames[] = {
26954 (char *) "self",(char *) "other", NULL
26955 };
26956
26957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26959 if (!SWIG_IsOK(res1)) {
26960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26961 }
26962 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26963 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26964 if (!SWIG_IsOK(res2)) {
26965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26966 }
26967 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26968 {
26969 PyThreadState* __tstate = wxPyBeginAllowThreads();
26970 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26971 wxPyEndAllowThreads(__tstate);
26972 if (PyErr_Occurred()) SWIG_fail;
26973 }
26974 {
26975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26976 }
26977 return resultobj;
26978 fail:
26979 return NULL;
26980 }
26981
26982
26983 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26984 PyObject *resultobj = 0;
26985 wxDateTime *arg1 = (wxDateTime *) 0 ;
26986 wxDateTime *arg2 = (wxDateTime *) 0 ;
26987 bool result;
26988 void *argp1 = 0 ;
26989 int res1 = 0 ;
26990 void *argp2 = 0 ;
26991 int res2 = 0 ;
26992 PyObject * obj0 = 0 ;
26993 PyObject * obj1 = 0 ;
26994 char * kwnames[] = {
26995 (char *) "self",(char *) "other", NULL
26996 };
26997
26998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27000 if (!SWIG_IsOK(res1)) {
27001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
27002 }
27003 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
27005 if (!SWIG_IsOK(res2)) {
27006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
27007 }
27008 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27009 {
27010 PyThreadState* __tstate = wxPyBeginAllowThreads();
27011 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
27012 wxPyEndAllowThreads(__tstate);
27013 if (PyErr_Occurred()) SWIG_fail;
27014 }
27015 {
27016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27017 }
27018 return resultobj;
27019 fail:
27020 return NULL;
27021 }
27022
27023
27024 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27025 PyObject *resultobj = 0;
27026 wxDateTime *arg1 = (wxDateTime *) 0 ;
27027 wxString *arg2 = 0 ;
27028 int result;
27029 void *argp1 = 0 ;
27030 int res1 = 0 ;
27031 bool temp2 = false ;
27032 PyObject * obj0 = 0 ;
27033 PyObject * obj1 = 0 ;
27034 char * kwnames[] = {
27035 (char *) "self",(char *) "date", NULL
27036 };
27037
27038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) SWIG_fail;
27039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27040 if (!SWIG_IsOK(res1)) {
27041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
27042 }
27043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27044 {
27045 arg2 = wxString_in_helper(obj1);
27046 if (arg2 == NULL) SWIG_fail;
27047 temp2 = true;
27048 }
27049 {
27050 PyThreadState* __tstate = wxPyBeginAllowThreads();
27051 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
27052 wxPyEndAllowThreads(__tstate);
27053 if (PyErr_Occurred()) SWIG_fail;
27054 }
27055 resultobj = SWIG_From_int(static_cast< int >(result));
27056 {
27057 if (temp2)
27058 delete arg2;
27059 }
27060 return resultobj;
27061 fail:
27062 {
27063 if (temp2)
27064 delete arg2;
27065 }
27066 return NULL;
27067 }
27068
27069
27070 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27071 PyObject *resultobj = 0;
27072 wxDateTime *arg1 = (wxDateTime *) 0 ;
27073 wxString *arg2 = 0 ;
27074 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
27075 wxString *arg3 = (wxString *) &arg3_defvalue ;
27076 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
27077 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
27078 int result;
27079 void *argp1 = 0 ;
27080 int res1 = 0 ;
27081 bool temp2 = false ;
27082 bool temp3 = false ;
27083 void *argp4 = 0 ;
27084 int res4 = 0 ;
27085 PyObject * obj0 = 0 ;
27086 PyObject * obj1 = 0 ;
27087 PyObject * obj2 = 0 ;
27088 PyObject * obj3 = 0 ;
27089 char * kwnames[] = {
27090 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
27091 };
27092
27093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27095 if (!SWIG_IsOK(res1)) {
27096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
27097 }
27098 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27099 {
27100 arg2 = wxString_in_helper(obj1);
27101 if (arg2 == NULL) SWIG_fail;
27102 temp2 = true;
27103 }
27104 if (obj2) {
27105 {
27106 arg3 = wxString_in_helper(obj2);
27107 if (arg3 == NULL) SWIG_fail;
27108 temp3 = true;
27109 }
27110 }
27111 if (obj3) {
27112 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
27113 if (!SWIG_IsOK(res4)) {
27114 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27115 }
27116 if (!argp4) {
27117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
27118 }
27119 arg4 = reinterpret_cast< wxDateTime * >(argp4);
27120 }
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 resultobj = SWIG_From_int(static_cast< int >(result));
27128 {
27129 if (temp2)
27130 delete arg2;
27131 }
27132 {
27133 if (temp3)
27134 delete arg3;
27135 }
27136 return resultobj;
27137 fail:
27138 {
27139 if (temp2)
27140 delete arg2;
27141 }
27142 {
27143 if (temp3)
27144 delete arg3;
27145 }
27146 return NULL;
27147 }
27148
27149
27150 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27151 PyObject *resultobj = 0;
27152 wxDateTime *arg1 = (wxDateTime *) 0 ;
27153 wxString *arg2 = 0 ;
27154 int result;
27155 void *argp1 = 0 ;
27156 int res1 = 0 ;
27157 bool temp2 = false ;
27158 PyObject * obj0 = 0 ;
27159 PyObject * obj1 = 0 ;
27160 char * kwnames[] = {
27161 (char *) "self",(char *) "datetime", NULL
27162 };
27163
27164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
27165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27166 if (!SWIG_IsOK(res1)) {
27167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27168 }
27169 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27170 {
27171 arg2 = wxString_in_helper(obj1);
27172 if (arg2 == NULL) SWIG_fail;
27173 temp2 = true;
27174 }
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
27178 wxPyEndAllowThreads(__tstate);
27179 if (PyErr_Occurred()) SWIG_fail;
27180 }
27181 resultobj = SWIG_From_int(static_cast< int >(result));
27182 {
27183 if (temp2)
27184 delete arg2;
27185 }
27186 return resultobj;
27187 fail:
27188 {
27189 if (temp2)
27190 delete arg2;
27191 }
27192 return NULL;
27193 }
27194
27195
27196 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27197 PyObject *resultobj = 0;
27198 wxDateTime *arg1 = (wxDateTime *) 0 ;
27199 wxString *arg2 = 0 ;
27200 int result;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 bool temp2 = false ;
27204 PyObject * obj0 = 0 ;
27205 PyObject * obj1 = 0 ;
27206 char * kwnames[] = {
27207 (char *) "self",(char *) "date", NULL
27208 };
27209
27210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27212 if (!SWIG_IsOK(res1)) {
27213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27214 }
27215 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27216 {
27217 arg2 = wxString_in_helper(obj1);
27218 if (arg2 == NULL) SWIG_fail;
27219 temp2 = true;
27220 }
27221 {
27222 PyThreadState* __tstate = wxPyBeginAllowThreads();
27223 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27224 wxPyEndAllowThreads(__tstate);
27225 if (PyErr_Occurred()) SWIG_fail;
27226 }
27227 resultobj = SWIG_From_int(static_cast< int >(result));
27228 {
27229 if (temp2)
27230 delete arg2;
27231 }
27232 return resultobj;
27233 fail:
27234 {
27235 if (temp2)
27236 delete arg2;
27237 }
27238 return NULL;
27239 }
27240
27241
27242 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27243 PyObject *resultobj = 0;
27244 wxDateTime *arg1 = (wxDateTime *) 0 ;
27245 wxString *arg2 = 0 ;
27246 int result;
27247 void *argp1 = 0 ;
27248 int res1 = 0 ;
27249 bool temp2 = false ;
27250 PyObject * obj0 = 0 ;
27251 PyObject * obj1 = 0 ;
27252 char * kwnames[] = {
27253 (char *) "self",(char *) "time", NULL
27254 };
27255
27256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27258 if (!SWIG_IsOK(res1)) {
27259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27260 }
27261 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27262 {
27263 arg2 = wxString_in_helper(obj1);
27264 if (arg2 == NULL) SWIG_fail;
27265 temp2 = true;
27266 }
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27270 wxPyEndAllowThreads(__tstate);
27271 if (PyErr_Occurred()) SWIG_fail;
27272 }
27273 resultobj = SWIG_From_int(static_cast< int >(result));
27274 {
27275 if (temp2)
27276 delete arg2;
27277 }
27278 return resultobj;
27279 fail:
27280 {
27281 if (temp2)
27282 delete arg2;
27283 }
27284 return NULL;
27285 }
27286
27287
27288 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27289 PyObject *resultobj = 0;
27290 wxDateTime *arg1 = (wxDateTime *) 0 ;
27291 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27292 wxString *arg2 = (wxString *) &arg2_defvalue ;
27293 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27294 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27295 wxString result;
27296 void *argp1 = 0 ;
27297 int res1 = 0 ;
27298 bool temp2 = false ;
27299 bool temp3 = false ;
27300 PyObject * obj0 = 0 ;
27301 PyObject * obj1 = 0 ;
27302 PyObject * obj2 = 0 ;
27303 char * kwnames[] = {
27304 (char *) "self",(char *) "format",(char *) "tz", NULL
27305 };
27306
27307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27309 if (!SWIG_IsOK(res1)) {
27310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27311 }
27312 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27313 if (obj1) {
27314 {
27315 arg2 = wxString_in_helper(obj1);
27316 if (arg2 == NULL) SWIG_fail;
27317 temp2 = true;
27318 }
27319 }
27320 if (obj2) {
27321 {
27322 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27323 temp3 = true;
27324 }
27325 }
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27329 wxPyEndAllowThreads(__tstate);
27330 if (PyErr_Occurred()) SWIG_fail;
27331 }
27332 {
27333 #if wxUSE_UNICODE
27334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27335 #else
27336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27337 #endif
27338 }
27339 {
27340 if (temp2)
27341 delete arg2;
27342 }
27343 {
27344 if (temp3) delete arg3;
27345 }
27346 return resultobj;
27347 fail:
27348 {
27349 if (temp2)
27350 delete arg2;
27351 }
27352 {
27353 if (temp3) delete arg3;
27354 }
27355 return NULL;
27356 }
27357
27358
27359 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27360 PyObject *resultobj = 0;
27361 wxDateTime *arg1 = (wxDateTime *) 0 ;
27362 wxString result;
27363 void *argp1 = 0 ;
27364 int res1 = 0 ;
27365 PyObject *swig_obj[1] ;
27366
27367 if (!args) SWIG_fail;
27368 swig_obj[0] = args;
27369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27370 if (!SWIG_IsOK(res1)) {
27371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27372 }
27373 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 result = ((wxDateTime const *)arg1)->FormatDate();
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 {
27381 #if wxUSE_UNICODE
27382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27383 #else
27384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27385 #endif
27386 }
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27394 PyObject *resultobj = 0;
27395 wxDateTime *arg1 = (wxDateTime *) 0 ;
27396 wxString result;
27397 void *argp1 = 0 ;
27398 int res1 = 0 ;
27399 PyObject *swig_obj[1] ;
27400
27401 if (!args) SWIG_fail;
27402 swig_obj[0] = args;
27403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27404 if (!SWIG_IsOK(res1)) {
27405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27406 }
27407 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27408 {
27409 PyThreadState* __tstate = wxPyBeginAllowThreads();
27410 result = ((wxDateTime const *)arg1)->FormatTime();
27411 wxPyEndAllowThreads(__tstate);
27412 if (PyErr_Occurred()) SWIG_fail;
27413 }
27414 {
27415 #if wxUSE_UNICODE
27416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27417 #else
27418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27419 #endif
27420 }
27421 return resultobj;
27422 fail:
27423 return NULL;
27424 }
27425
27426
27427 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27428 PyObject *resultobj = 0;
27429 wxDateTime *arg1 = (wxDateTime *) 0 ;
27430 wxString result;
27431 void *argp1 = 0 ;
27432 int res1 = 0 ;
27433 PyObject *swig_obj[1] ;
27434
27435 if (!args) SWIG_fail;
27436 swig_obj[0] = args;
27437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27438 if (!SWIG_IsOK(res1)) {
27439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27440 }
27441 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = ((wxDateTime const *)arg1)->FormatISODate();
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 {
27449 #if wxUSE_UNICODE
27450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27451 #else
27452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27453 #endif
27454 }
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27462 PyObject *resultobj = 0;
27463 wxDateTime *arg1 = (wxDateTime *) 0 ;
27464 wxString result;
27465 void *argp1 = 0 ;
27466 int res1 = 0 ;
27467 PyObject *swig_obj[1] ;
27468
27469 if (!args) SWIG_fail;
27470 swig_obj[0] = args;
27471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27472 if (!SWIG_IsOK(res1)) {
27473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27474 }
27475 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27476 {
27477 PyThreadState* __tstate = wxPyBeginAllowThreads();
27478 result = ((wxDateTime const *)arg1)->FormatISOTime();
27479 wxPyEndAllowThreads(__tstate);
27480 if (PyErr_Occurred()) SWIG_fail;
27481 }
27482 {
27483 #if wxUSE_UNICODE
27484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27485 #else
27486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27487 #endif
27488 }
27489 return resultobj;
27490 fail:
27491 return NULL;
27492 }
27493
27494
27495 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27496 PyObject *obj;
27497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27498 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27499 return SWIG_Py_Void();
27500 }
27501
27502 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27503 return SWIG_Python_InitShadowInstance(args);
27504 }
27505
27506 SWIGINTERN PyObject *_wrap_TimeSpan_Milliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27507 PyObject *resultobj = 0;
27508 long arg1 ;
27509 wxTimeSpan result;
27510 long val1 ;
27511 int ecode1 = 0 ;
27512 PyObject * obj0 = 0 ;
27513 char * kwnames[] = {
27514 (char *) "ms", NULL
27515 };
27516
27517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Milliseconds",kwnames,&obj0)) SWIG_fail;
27518 ecode1 = SWIG_AsVal_long(obj0, &val1);
27519 if (!SWIG_IsOK(ecode1)) {
27520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Milliseconds" "', expected argument " "1"" of type '" "long""'");
27521 }
27522 arg1 = static_cast< long >(val1);
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 result = wxTimeSpan::Milliseconds(arg1);
27526 wxPyEndAllowThreads(__tstate);
27527 if (PyErr_Occurred()) SWIG_fail;
27528 }
27529 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27530 return resultobj;
27531 fail:
27532 return NULL;
27533 }
27534
27535
27536 SWIGINTERN PyObject *_wrap_TimeSpan_Millisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27537 PyObject *resultobj = 0;
27538 wxTimeSpan result;
27539
27540 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Millisecond",0,0,0)) SWIG_fail;
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 result = wxTimeSpan::Millisecond();
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27555 PyObject *resultobj = 0;
27556 long arg1 ;
27557 wxTimeSpan result;
27558 long val1 ;
27559 int ecode1 = 0 ;
27560 PyObject * obj0 = 0 ;
27561 char * kwnames[] = {
27562 (char *) "sec", NULL
27563 };
27564
27565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27566 ecode1 = SWIG_AsVal_long(obj0, &val1);
27567 if (!SWIG_IsOK(ecode1)) {
27568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27569 }
27570 arg1 = static_cast< long >(val1);
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 result = wxTimeSpan::Seconds(arg1);
27574 wxPyEndAllowThreads(__tstate);
27575 if (PyErr_Occurred()) SWIG_fail;
27576 }
27577 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27578 return resultobj;
27579 fail:
27580 return NULL;
27581 }
27582
27583
27584 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27585 PyObject *resultobj = 0;
27586 wxTimeSpan result;
27587
27588 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27589 {
27590 PyThreadState* __tstate = wxPyBeginAllowThreads();
27591 result = wxTimeSpan::Second();
27592 wxPyEndAllowThreads(__tstate);
27593 if (PyErr_Occurred()) SWIG_fail;
27594 }
27595 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27596 return resultobj;
27597 fail:
27598 return NULL;
27599 }
27600
27601
27602 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27603 PyObject *resultobj = 0;
27604 long arg1 ;
27605 wxTimeSpan result;
27606 long val1 ;
27607 int ecode1 = 0 ;
27608 PyObject * obj0 = 0 ;
27609 char * kwnames[] = {
27610 (char *) "min", NULL
27611 };
27612
27613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27614 ecode1 = SWIG_AsVal_long(obj0, &val1);
27615 if (!SWIG_IsOK(ecode1)) {
27616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27617 }
27618 arg1 = static_cast< long >(val1);
27619 {
27620 PyThreadState* __tstate = wxPyBeginAllowThreads();
27621 result = wxTimeSpan::Minutes(arg1);
27622 wxPyEndAllowThreads(__tstate);
27623 if (PyErr_Occurred()) SWIG_fail;
27624 }
27625 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27633 PyObject *resultobj = 0;
27634 wxTimeSpan result;
27635
27636 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27637 {
27638 PyThreadState* __tstate = wxPyBeginAllowThreads();
27639 result = wxTimeSpan::Minute();
27640 wxPyEndAllowThreads(__tstate);
27641 if (PyErr_Occurred()) SWIG_fail;
27642 }
27643 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27644 return resultobj;
27645 fail:
27646 return NULL;
27647 }
27648
27649
27650 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27651 PyObject *resultobj = 0;
27652 long arg1 ;
27653 wxTimeSpan result;
27654 long val1 ;
27655 int ecode1 = 0 ;
27656 PyObject * obj0 = 0 ;
27657 char * kwnames[] = {
27658 (char *) "hours", NULL
27659 };
27660
27661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27662 ecode1 = SWIG_AsVal_long(obj0, &val1);
27663 if (!SWIG_IsOK(ecode1)) {
27664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27665 }
27666 arg1 = static_cast< long >(val1);
27667 {
27668 PyThreadState* __tstate = wxPyBeginAllowThreads();
27669 result = wxTimeSpan::Hours(arg1);
27670 wxPyEndAllowThreads(__tstate);
27671 if (PyErr_Occurred()) SWIG_fail;
27672 }
27673 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27674 return resultobj;
27675 fail:
27676 return NULL;
27677 }
27678
27679
27680 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27681 PyObject *resultobj = 0;
27682 wxTimeSpan result;
27683
27684 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27685 {
27686 PyThreadState* __tstate = wxPyBeginAllowThreads();
27687 result = wxTimeSpan::Hour();
27688 wxPyEndAllowThreads(__tstate);
27689 if (PyErr_Occurred()) SWIG_fail;
27690 }
27691 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27692 return resultobj;
27693 fail:
27694 return NULL;
27695 }
27696
27697
27698 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj = 0;
27700 long arg1 ;
27701 wxTimeSpan result;
27702 long val1 ;
27703 int ecode1 = 0 ;
27704 PyObject * obj0 = 0 ;
27705 char * kwnames[] = {
27706 (char *) "days", NULL
27707 };
27708
27709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27710 ecode1 = SWIG_AsVal_long(obj0, &val1);
27711 if (!SWIG_IsOK(ecode1)) {
27712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27713 }
27714 arg1 = static_cast< long >(val1);
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = wxTimeSpan::Days(arg1);
27718 wxPyEndAllowThreads(__tstate);
27719 if (PyErr_Occurred()) SWIG_fail;
27720 }
27721 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27722 return resultobj;
27723 fail:
27724 return NULL;
27725 }
27726
27727
27728 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27729 PyObject *resultobj = 0;
27730 wxTimeSpan result;
27731
27732 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = wxTimeSpan::Day();
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27747 PyObject *resultobj = 0;
27748 long arg1 ;
27749 wxTimeSpan result;
27750 long val1 ;
27751 int ecode1 = 0 ;
27752 PyObject * obj0 = 0 ;
27753 char * kwnames[] = {
27754 (char *) "days", NULL
27755 };
27756
27757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27758 ecode1 = SWIG_AsVal_long(obj0, &val1);
27759 if (!SWIG_IsOK(ecode1)) {
27760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27761 }
27762 arg1 = static_cast< long >(val1);
27763 {
27764 PyThreadState* __tstate = wxPyBeginAllowThreads();
27765 result = wxTimeSpan::Weeks(arg1);
27766 wxPyEndAllowThreads(__tstate);
27767 if (PyErr_Occurred()) SWIG_fail;
27768 }
27769 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27770 return resultobj;
27771 fail:
27772 return NULL;
27773 }
27774
27775
27776 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27777 PyObject *resultobj = 0;
27778 wxTimeSpan result;
27779
27780 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27781 {
27782 PyThreadState* __tstate = wxPyBeginAllowThreads();
27783 result = wxTimeSpan::Week();
27784 wxPyEndAllowThreads(__tstate);
27785 if (PyErr_Occurred()) SWIG_fail;
27786 }
27787 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27788 return resultobj;
27789 fail:
27790 return NULL;
27791 }
27792
27793
27794 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27795 PyObject *resultobj = 0;
27796 long arg1 = (long) 0 ;
27797 long arg2 = (long) 0 ;
27798 long arg3 = (long) 0 ;
27799 long arg4 = (long) 0 ;
27800 wxTimeSpan *result = 0 ;
27801 long val1 ;
27802 int ecode1 = 0 ;
27803 long val2 ;
27804 int ecode2 = 0 ;
27805 long val3 ;
27806 int ecode3 = 0 ;
27807 long val4 ;
27808 int ecode4 = 0 ;
27809 PyObject * obj0 = 0 ;
27810 PyObject * obj1 = 0 ;
27811 PyObject * obj2 = 0 ;
27812 PyObject * obj3 = 0 ;
27813 char * kwnames[] = {
27814 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27815 };
27816
27817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27818 if (obj0) {
27819 ecode1 = SWIG_AsVal_long(obj0, &val1);
27820 if (!SWIG_IsOK(ecode1)) {
27821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27822 }
27823 arg1 = static_cast< long >(val1);
27824 }
27825 if (obj1) {
27826 ecode2 = SWIG_AsVal_long(obj1, &val2);
27827 if (!SWIG_IsOK(ecode2)) {
27828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27829 }
27830 arg2 = static_cast< long >(val2);
27831 }
27832 if (obj2) {
27833 ecode3 = SWIG_AsVal_long(obj2, &val3);
27834 if (!SWIG_IsOK(ecode3)) {
27835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27836 }
27837 arg3 = static_cast< long >(val3);
27838 }
27839 if (obj3) {
27840 ecode4 = SWIG_AsVal_long(obj3, &val4);
27841 if (!SWIG_IsOK(ecode4)) {
27842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27843 }
27844 arg4 = static_cast< long >(val4);
27845 }
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27853 return resultobj;
27854 fail:
27855 return NULL;
27856 }
27857
27858
27859 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27860 PyObject *resultobj = 0;
27861 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27862 void *argp1 = 0 ;
27863 int res1 = 0 ;
27864 PyObject *swig_obj[1] ;
27865
27866 if (!args) SWIG_fail;
27867 swig_obj[0] = args;
27868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27871 }
27872 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 delete arg1;
27876
27877 wxPyEndAllowThreads(__tstate);
27878 if (PyErr_Occurred()) SWIG_fail;
27879 }
27880 resultobj = SWIG_Py_Void();
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27888 PyObject *resultobj = 0;
27889 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27890 wxTimeSpan *arg2 = 0 ;
27891 wxTimeSpan *result = 0 ;
27892 void *argp1 = 0 ;
27893 int res1 = 0 ;
27894 void *argp2 = 0 ;
27895 int res2 = 0 ;
27896 PyObject * obj0 = 0 ;
27897 PyObject * obj1 = 0 ;
27898 char * kwnames[] = {
27899 (char *) "self",(char *) "diff", NULL
27900 };
27901
27902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27904 if (!SWIG_IsOK(res1)) {
27905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27906 }
27907 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27908 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27909 if (!SWIG_IsOK(res2)) {
27910 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27911 }
27912 if (!argp2) {
27913 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27914 }
27915 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 {
27919 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27920 result = (wxTimeSpan *) &_result_ref;
27921 }
27922 wxPyEndAllowThreads(__tstate);
27923 if (PyErr_Occurred()) SWIG_fail;
27924 }
27925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27933 PyObject *resultobj = 0;
27934 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27935 wxTimeSpan *arg2 = 0 ;
27936 wxTimeSpan *result = 0 ;
27937 void *argp1 = 0 ;
27938 int res1 = 0 ;
27939 void *argp2 = 0 ;
27940 int res2 = 0 ;
27941 PyObject * obj0 = 0 ;
27942 PyObject * obj1 = 0 ;
27943 char * kwnames[] = {
27944 (char *) "self",(char *) "diff", NULL
27945 };
27946
27947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27949 if (!SWIG_IsOK(res1)) {
27950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27951 }
27952 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27953 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27954 if (!SWIG_IsOK(res2)) {
27955 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27956 }
27957 if (!argp2) {
27958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27959 }
27960 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 {
27964 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27965 result = (wxTimeSpan *) &_result_ref;
27966 }
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27978 PyObject *resultobj = 0;
27979 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27980 int arg2 ;
27981 wxTimeSpan *result = 0 ;
27982 void *argp1 = 0 ;
27983 int res1 = 0 ;
27984 int val2 ;
27985 int ecode2 = 0 ;
27986 PyObject * obj0 = 0 ;
27987 PyObject * obj1 = 0 ;
27988 char * kwnames[] = {
27989 (char *) "self",(char *) "n", NULL
27990 };
27991
27992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27994 if (!SWIG_IsOK(res1)) {
27995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27996 }
27997 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27998 ecode2 = SWIG_AsVal_int(obj1, &val2);
27999 if (!SWIG_IsOK(ecode2)) {
28000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
28001 }
28002 arg2 = static_cast< int >(val2);
28003 {
28004 PyThreadState* __tstate = wxPyBeginAllowThreads();
28005 {
28006 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
28007 result = (wxTimeSpan *) &_result_ref;
28008 }
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28013 return resultobj;
28014 fail:
28015 return NULL;
28016 }
28017
28018
28019 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28020 PyObject *resultobj = 0;
28021 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28022 wxTimeSpan *result = 0 ;
28023 void *argp1 = 0 ;
28024 int res1 = 0 ;
28025 PyObject *swig_obj[1] ;
28026
28027 if (!args) SWIG_fail;
28028 swig_obj[0] = args;
28029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28030 if (!SWIG_IsOK(res1)) {
28031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28032 }
28033 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28034 {
28035 PyThreadState* __tstate = wxPyBeginAllowThreads();
28036 {
28037 wxTimeSpan &_result_ref = (arg1)->Neg();
28038 result = (wxTimeSpan *) &_result_ref;
28039 }
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28044 return resultobj;
28045 fail:
28046 return NULL;
28047 }
28048
28049
28050 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28051 PyObject *resultobj = 0;
28052 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28053 wxTimeSpan result;
28054 void *argp1 = 0 ;
28055 int res1 = 0 ;
28056 PyObject *swig_obj[1] ;
28057
28058 if (!args) SWIG_fail;
28059 swig_obj[0] = args;
28060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28061 if (!SWIG_IsOK(res1)) {
28062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28063 }
28064 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28065 {
28066 PyThreadState* __tstate = wxPyBeginAllowThreads();
28067 result = ((wxTimeSpan const *)arg1)->Abs();
28068 wxPyEndAllowThreads(__tstate);
28069 if (PyErr_Occurred()) SWIG_fail;
28070 }
28071 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28072 return resultobj;
28073 fail:
28074 return NULL;
28075 }
28076
28077
28078 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28079 PyObject *resultobj = 0;
28080 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28081 wxTimeSpan *arg2 = 0 ;
28082 wxTimeSpan *result = 0 ;
28083 void *argp1 = 0 ;
28084 int res1 = 0 ;
28085 void *argp2 = 0 ;
28086 int res2 = 0 ;
28087 PyObject * obj0 = 0 ;
28088 PyObject * obj1 = 0 ;
28089 char * kwnames[] = {
28090 (char *) "self",(char *) "diff", NULL
28091 };
28092
28093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
28094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28095 if (!SWIG_IsOK(res1)) {
28096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28097 }
28098 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28099 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28100 if (!SWIG_IsOK(res2)) {
28101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28102 }
28103 if (!argp2) {
28104 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28105 }
28106 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28107 {
28108 PyThreadState* __tstate = wxPyBeginAllowThreads();
28109 {
28110 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
28111 result = (wxTimeSpan *) &_result_ref;
28112 }
28113 wxPyEndAllowThreads(__tstate);
28114 if (PyErr_Occurred()) SWIG_fail;
28115 }
28116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28124 PyObject *resultobj = 0;
28125 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28126 wxTimeSpan *arg2 = 0 ;
28127 wxTimeSpan *result = 0 ;
28128 void *argp1 = 0 ;
28129 int res1 = 0 ;
28130 void *argp2 = 0 ;
28131 int res2 = 0 ;
28132 PyObject * obj0 = 0 ;
28133 PyObject * obj1 = 0 ;
28134 char * kwnames[] = {
28135 (char *) "self",(char *) "diff", NULL
28136 };
28137
28138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
28139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28140 if (!SWIG_IsOK(res1)) {
28141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28142 }
28143 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28144 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28145 if (!SWIG_IsOK(res2)) {
28146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28147 }
28148 if (!argp2) {
28149 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28150 }
28151 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28152 {
28153 PyThreadState* __tstate = wxPyBeginAllowThreads();
28154 {
28155 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
28156 result = (wxTimeSpan *) &_result_ref;
28157 }
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28162 return resultobj;
28163 fail:
28164 return NULL;
28165 }
28166
28167
28168 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28169 PyObject *resultobj = 0;
28170 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28171 int arg2 ;
28172 wxTimeSpan *result = 0 ;
28173 void *argp1 = 0 ;
28174 int res1 = 0 ;
28175 int val2 ;
28176 int ecode2 = 0 ;
28177 PyObject * obj0 = 0 ;
28178 PyObject * obj1 = 0 ;
28179 char * kwnames[] = {
28180 (char *) "self",(char *) "n", NULL
28181 };
28182
28183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
28184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
28185 if (!SWIG_IsOK(res1)) {
28186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28187 }
28188 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28189 ecode2 = SWIG_AsVal_int(obj1, &val2);
28190 if (!SWIG_IsOK(ecode2)) {
28191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
28192 }
28193 arg2 = static_cast< int >(val2);
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 {
28197 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
28198 result = (wxTimeSpan *) &_result_ref;
28199 }
28200 wxPyEndAllowThreads(__tstate);
28201 if (PyErr_Occurred()) SWIG_fail;
28202 }
28203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28211 PyObject *resultobj = 0;
28212 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28213 wxTimeSpan *result = 0 ;
28214 void *argp1 = 0 ;
28215 int res1 = 0 ;
28216 PyObject *swig_obj[1] ;
28217
28218 if (!args) SWIG_fail;
28219 swig_obj[0] = args;
28220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28221 if (!SWIG_IsOK(res1)) {
28222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28223 }
28224 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 {
28228 wxTimeSpan &_result_ref = (arg1)->operator -();
28229 result = (wxTimeSpan *) &_result_ref;
28230 }
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28242 PyObject *resultobj = 0;
28243 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28244 wxTimeSpan *arg2 = 0 ;
28245 wxTimeSpan result;
28246 void *argp1 = 0 ;
28247 int res1 = 0 ;
28248 void *argp2 = 0 ;
28249 int res2 = 0 ;
28250 PyObject * obj0 = 0 ;
28251 PyObject * obj1 = 0 ;
28252 char * kwnames[] = {
28253 (char *) "self",(char *) "other", NULL
28254 };
28255
28256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28258 if (!SWIG_IsOK(res1)) {
28259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28260 }
28261 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28262 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28263 if (!SWIG_IsOK(res2)) {
28264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28265 }
28266 if (!argp2) {
28267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28268 }
28269 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28273 wxPyEndAllowThreads(__tstate);
28274 if (PyErr_Occurred()) SWIG_fail;
28275 }
28276 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28277 return resultobj;
28278 fail:
28279 return NULL;
28280 }
28281
28282
28283 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28284 PyObject *resultobj = 0;
28285 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28286 wxTimeSpan *arg2 = 0 ;
28287 wxTimeSpan result;
28288 void *argp1 = 0 ;
28289 int res1 = 0 ;
28290 void *argp2 = 0 ;
28291 int res2 = 0 ;
28292 PyObject * obj0 = 0 ;
28293 PyObject * obj1 = 0 ;
28294 char * kwnames[] = {
28295 (char *) "self",(char *) "other", NULL
28296 };
28297
28298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28300 if (!SWIG_IsOK(res1)) {
28301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28302 }
28303 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28304 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28305 if (!SWIG_IsOK(res2)) {
28306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28307 }
28308 if (!argp2) {
28309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28310 }
28311 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28326 PyObject *resultobj = 0;
28327 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28328 int arg2 ;
28329 wxTimeSpan result;
28330 void *argp1 = 0 ;
28331 int res1 = 0 ;
28332 int val2 ;
28333 int ecode2 = 0 ;
28334 PyObject * obj0 = 0 ;
28335 PyObject * obj1 = 0 ;
28336 char * kwnames[] = {
28337 (char *) "self",(char *) "n", NULL
28338 };
28339
28340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28342 if (!SWIG_IsOK(res1)) {
28343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28344 }
28345 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28346 ecode2 = SWIG_AsVal_int(obj1, &val2);
28347 if (!SWIG_IsOK(ecode2)) {
28348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28349 }
28350 arg2 = static_cast< int >(val2);
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 result = wxTimeSpan___mul__(arg1,arg2);
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = 0;
28366 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28367 int arg2 ;
28368 wxTimeSpan result;
28369 void *argp1 = 0 ;
28370 int res1 = 0 ;
28371 int val2 ;
28372 int ecode2 = 0 ;
28373 PyObject * obj0 = 0 ;
28374 PyObject * obj1 = 0 ;
28375 char * kwnames[] = {
28376 (char *) "self",(char *) "n", NULL
28377 };
28378
28379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28381 if (!SWIG_IsOK(res1)) {
28382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28383 }
28384 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28385 ecode2 = SWIG_AsVal_int(obj1, &val2);
28386 if (!SWIG_IsOK(ecode2)) {
28387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28388 }
28389 arg2 = static_cast< int >(val2);
28390 {
28391 PyThreadState* __tstate = wxPyBeginAllowThreads();
28392 result = wxTimeSpan___rmul__(arg1,arg2);
28393 wxPyEndAllowThreads(__tstate);
28394 if (PyErr_Occurred()) SWIG_fail;
28395 }
28396 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28397 return resultobj;
28398 fail:
28399 return NULL;
28400 }
28401
28402
28403 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28404 PyObject *resultobj = 0;
28405 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28406 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28407 bool result;
28408 void *argp1 = 0 ;
28409 int res1 = 0 ;
28410 void *argp2 = 0 ;
28411 int res2 = 0 ;
28412 PyObject * obj0 = 0 ;
28413 PyObject * obj1 = 0 ;
28414 char * kwnames[] = {
28415 (char *) "self",(char *) "other", NULL
28416 };
28417
28418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28420 if (!SWIG_IsOK(res1)) {
28421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28422 }
28423 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28425 if (!SWIG_IsOK(res2)) {
28426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28427 }
28428 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28432 wxPyEndAllowThreads(__tstate);
28433 if (PyErr_Occurred()) SWIG_fail;
28434 }
28435 {
28436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28437 }
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28445 PyObject *resultobj = 0;
28446 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28447 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28448 bool result;
28449 void *argp1 = 0 ;
28450 int res1 = 0 ;
28451 void *argp2 = 0 ;
28452 int res2 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 PyObject * obj1 = 0 ;
28455 char * kwnames[] = {
28456 (char *) "self",(char *) "other", NULL
28457 };
28458
28459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28461 if (!SWIG_IsOK(res1)) {
28462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28463 }
28464 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28465 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28466 if (!SWIG_IsOK(res2)) {
28467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28468 }
28469 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28473 wxPyEndAllowThreads(__tstate);
28474 if (PyErr_Occurred()) SWIG_fail;
28475 }
28476 {
28477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28478 }
28479 return resultobj;
28480 fail:
28481 return NULL;
28482 }
28483
28484
28485 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28486 PyObject *resultobj = 0;
28487 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28488 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28489 bool result;
28490 void *argp1 = 0 ;
28491 int res1 = 0 ;
28492 void *argp2 = 0 ;
28493 int res2 = 0 ;
28494 PyObject * obj0 = 0 ;
28495 PyObject * obj1 = 0 ;
28496 char * kwnames[] = {
28497 (char *) "self",(char *) "other", NULL
28498 };
28499
28500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28502 if (!SWIG_IsOK(res1)) {
28503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28504 }
28505 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28506 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28507 if (!SWIG_IsOK(res2)) {
28508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28509 }
28510 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28511 {
28512 PyThreadState* __tstate = wxPyBeginAllowThreads();
28513 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28514 wxPyEndAllowThreads(__tstate);
28515 if (PyErr_Occurred()) SWIG_fail;
28516 }
28517 {
28518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28519 }
28520 return resultobj;
28521 fail:
28522 return NULL;
28523 }
28524
28525
28526 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28527 PyObject *resultobj = 0;
28528 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28529 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28530 bool result;
28531 void *argp1 = 0 ;
28532 int res1 = 0 ;
28533 void *argp2 = 0 ;
28534 int res2 = 0 ;
28535 PyObject * obj0 = 0 ;
28536 PyObject * obj1 = 0 ;
28537 char * kwnames[] = {
28538 (char *) "self",(char *) "other", NULL
28539 };
28540
28541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28543 if (!SWIG_IsOK(res1)) {
28544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28545 }
28546 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28548 if (!SWIG_IsOK(res2)) {
28549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28550 }
28551 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28555 wxPyEndAllowThreads(__tstate);
28556 if (PyErr_Occurred()) SWIG_fail;
28557 }
28558 {
28559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28560 }
28561 return resultobj;
28562 fail:
28563 return NULL;
28564 }
28565
28566
28567 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28568 PyObject *resultobj = 0;
28569 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28570 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28571 bool result;
28572 void *argp1 = 0 ;
28573 int res1 = 0 ;
28574 void *argp2 = 0 ;
28575 int res2 = 0 ;
28576 PyObject * obj0 = 0 ;
28577 PyObject * obj1 = 0 ;
28578 char * kwnames[] = {
28579 (char *) "self",(char *) "other", NULL
28580 };
28581
28582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28586 }
28587 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28589 if (!SWIG_IsOK(res2)) {
28590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28591 }
28592 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28596 wxPyEndAllowThreads(__tstate);
28597 if (PyErr_Occurred()) SWIG_fail;
28598 }
28599 {
28600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28601 }
28602 return resultobj;
28603 fail:
28604 return NULL;
28605 }
28606
28607
28608 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28609 PyObject *resultobj = 0;
28610 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28611 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28612 bool result;
28613 void *argp1 = 0 ;
28614 int res1 = 0 ;
28615 void *argp2 = 0 ;
28616 int res2 = 0 ;
28617 PyObject * obj0 = 0 ;
28618 PyObject * obj1 = 0 ;
28619 char * kwnames[] = {
28620 (char *) "self",(char *) "other", NULL
28621 };
28622
28623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28625 if (!SWIG_IsOK(res1)) {
28626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28627 }
28628 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28630 if (!SWIG_IsOK(res2)) {
28631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28632 }
28633 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 {
28641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28642 }
28643 return resultobj;
28644 fail:
28645 return NULL;
28646 }
28647
28648
28649 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28650 PyObject *resultobj = 0;
28651 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28652 bool result;
28653 void *argp1 = 0 ;
28654 int res1 = 0 ;
28655 PyObject *swig_obj[1] ;
28656
28657 if (!args) SWIG_fail;
28658 swig_obj[0] = args;
28659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28660 if (!SWIG_IsOK(res1)) {
28661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28662 }
28663 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 {
28671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28672 }
28673 return resultobj;
28674 fail:
28675 return NULL;
28676 }
28677
28678
28679 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28680 PyObject *resultobj = 0;
28681 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28682 bool result;
28683 void *argp1 = 0 ;
28684 int res1 = 0 ;
28685 PyObject *swig_obj[1] ;
28686
28687 if (!args) SWIG_fail;
28688 swig_obj[0] = args;
28689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28690 if (!SWIG_IsOK(res1)) {
28691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28692 }
28693 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28694 {
28695 PyThreadState* __tstate = wxPyBeginAllowThreads();
28696 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28697 wxPyEndAllowThreads(__tstate);
28698 if (PyErr_Occurred()) SWIG_fail;
28699 }
28700 {
28701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28702 }
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28710 PyObject *resultobj = 0;
28711 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28712 bool result;
28713 void *argp1 = 0 ;
28714 int res1 = 0 ;
28715 PyObject *swig_obj[1] ;
28716
28717 if (!args) SWIG_fail;
28718 swig_obj[0] = args;
28719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28720 if (!SWIG_IsOK(res1)) {
28721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28722 }
28723 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28724 {
28725 PyThreadState* __tstate = wxPyBeginAllowThreads();
28726 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 {
28731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28732 }
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28740 PyObject *resultobj = 0;
28741 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28742 wxTimeSpan *arg2 = 0 ;
28743 bool result;
28744 void *argp1 = 0 ;
28745 int res1 = 0 ;
28746 void *argp2 = 0 ;
28747 int res2 = 0 ;
28748 PyObject * obj0 = 0 ;
28749 PyObject * obj1 = 0 ;
28750 char * kwnames[] = {
28751 (char *) "self",(char *) "ts", NULL
28752 };
28753
28754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28756 if (!SWIG_IsOK(res1)) {
28757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28758 }
28759 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28761 if (!SWIG_IsOK(res2)) {
28762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28763 }
28764 if (!argp2) {
28765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28766 }
28767 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28768 {
28769 PyThreadState* __tstate = wxPyBeginAllowThreads();
28770 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 {
28775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28776 }
28777 return resultobj;
28778 fail:
28779 return NULL;
28780 }
28781
28782
28783 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28784 PyObject *resultobj = 0;
28785 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28786 wxTimeSpan *arg2 = 0 ;
28787 bool result;
28788 void *argp1 = 0 ;
28789 int res1 = 0 ;
28790 void *argp2 = 0 ;
28791 int res2 = 0 ;
28792 PyObject * obj0 = 0 ;
28793 PyObject * obj1 = 0 ;
28794 char * kwnames[] = {
28795 (char *) "self",(char *) "ts", NULL
28796 };
28797
28798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28800 if (!SWIG_IsOK(res1)) {
28801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28802 }
28803 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28804 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28805 if (!SWIG_IsOK(res2)) {
28806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28807 }
28808 if (!argp2) {
28809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28810 }
28811 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28812 {
28813 PyThreadState* __tstate = wxPyBeginAllowThreads();
28814 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 {
28819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28820 }
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28828 PyObject *resultobj = 0;
28829 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28830 wxTimeSpan *arg2 = 0 ;
28831 bool result;
28832 void *argp1 = 0 ;
28833 int res1 = 0 ;
28834 void *argp2 = 0 ;
28835 int res2 = 0 ;
28836 PyObject * obj0 = 0 ;
28837 PyObject * obj1 = 0 ;
28838 char * kwnames[] = {
28839 (char *) "self",(char *) "t", NULL
28840 };
28841
28842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28844 if (!SWIG_IsOK(res1)) {
28845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28846 }
28847 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28848 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28849 if (!SWIG_IsOK(res2)) {
28850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28851 }
28852 if (!argp2) {
28853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28854 }
28855 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 {
28863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28864 }
28865 return resultobj;
28866 fail:
28867 return NULL;
28868 }
28869
28870
28871 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28872 PyObject *resultobj = 0;
28873 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28874 int result;
28875 void *argp1 = 0 ;
28876 int res1 = 0 ;
28877 PyObject *swig_obj[1] ;
28878
28879 if (!args) SWIG_fail;
28880 swig_obj[0] = args;
28881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28882 if (!SWIG_IsOK(res1)) {
28883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28884 }
28885 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28886 {
28887 PyThreadState* __tstate = wxPyBeginAllowThreads();
28888 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28889 wxPyEndAllowThreads(__tstate);
28890 if (PyErr_Occurred()) SWIG_fail;
28891 }
28892 resultobj = SWIG_From_int(static_cast< int >(result));
28893 return resultobj;
28894 fail:
28895 return NULL;
28896 }
28897
28898
28899 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28900 PyObject *resultobj = 0;
28901 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28902 int result;
28903 void *argp1 = 0 ;
28904 int res1 = 0 ;
28905 PyObject *swig_obj[1] ;
28906
28907 if (!args) SWIG_fail;
28908 swig_obj[0] = args;
28909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28910 if (!SWIG_IsOK(res1)) {
28911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28912 }
28913 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 resultobj = SWIG_From_int(static_cast< int >(result));
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28930 int result;
28931 void *argp1 = 0 ;
28932 int res1 = 0 ;
28933 PyObject *swig_obj[1] ;
28934
28935 if (!args) SWIG_fail;
28936 swig_obj[0] = args;
28937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28938 if (!SWIG_IsOK(res1)) {
28939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28940 }
28941 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28942 {
28943 PyThreadState* __tstate = wxPyBeginAllowThreads();
28944 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 resultobj = SWIG_From_int(static_cast< int >(result));
28949 return resultobj;
28950 fail:
28951 return NULL;
28952 }
28953
28954
28955 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28956 PyObject *resultobj = 0;
28957 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28958 int result;
28959 void *argp1 = 0 ;
28960 int res1 = 0 ;
28961 PyObject *swig_obj[1] ;
28962
28963 if (!args) SWIG_fail;
28964 swig_obj[0] = args;
28965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28966 if (!SWIG_IsOK(res1)) {
28967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28968 }
28969 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28973 wxPyEndAllowThreads(__tstate);
28974 if (PyErr_Occurred()) SWIG_fail;
28975 }
28976 resultobj = SWIG_From_int(static_cast< int >(result));
28977 return resultobj;
28978 fail:
28979 return NULL;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28984 PyObject *resultobj = 0;
28985 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28986 wxLongLong result;
28987 void *argp1 = 0 ;
28988 int res1 = 0 ;
28989 PyObject *swig_obj[1] ;
28990
28991 if (!args) SWIG_fail;
28992 swig_obj[0] = args;
28993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28994 if (!SWIG_IsOK(res1)) {
28995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28996 }
28997 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28998 {
28999 PyThreadState* __tstate = wxPyBeginAllowThreads();
29000 result = ((wxTimeSpan const *)arg1)->GetSeconds();
29001 wxPyEndAllowThreads(__tstate);
29002 if (PyErr_Occurred()) SWIG_fail;
29003 }
29004 {
29005 PyObject *hi, *lo, *shifter, *shifted;
29006 hi = PyLong_FromLong( (&result)->GetHi() );
29007 lo = PyLong_FromLong( (&result)->GetLo() );
29008 shifter = PyLong_FromLong(32);
29009 shifted = PyNumber_Lshift(hi, shifter);
29010 resultobj = PyNumber_Or(shifted, lo);
29011 Py_DECREF(hi);
29012 Py_DECREF(lo);
29013 Py_DECREF(shifter);
29014 Py_DECREF(shifted);
29015 }
29016 return resultobj;
29017 fail:
29018 return NULL;
29019 }
29020
29021
29022 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29023 PyObject *resultobj = 0;
29024 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29025 wxLongLong result;
29026 void *argp1 = 0 ;
29027 int res1 = 0 ;
29028 PyObject *swig_obj[1] ;
29029
29030 if (!args) SWIG_fail;
29031 swig_obj[0] = args;
29032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29033 if (!SWIG_IsOK(res1)) {
29034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29035 }
29036 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 {
29044 PyObject *hi, *lo, *shifter, *shifted;
29045 hi = PyLong_FromLong( (&result)->GetHi() );
29046 lo = PyLong_FromLong( (&result)->GetLo() );
29047 shifter = PyLong_FromLong(32);
29048 shifted = PyNumber_Lshift(hi, shifter);
29049 resultobj = PyNumber_Or(shifted, lo);
29050 Py_DECREF(hi);
29051 Py_DECREF(lo);
29052 Py_DECREF(shifter);
29053 Py_DECREF(shifted);
29054 }
29055 return resultobj;
29056 fail:
29057 return NULL;
29058 }
29059
29060
29061 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29062 PyObject *resultobj = 0;
29063 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
29064 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
29065 wxString *arg2 = (wxString *) &arg2_defvalue ;
29066 wxString result;
29067 void *argp1 = 0 ;
29068 int res1 = 0 ;
29069 bool temp2 = false ;
29070 PyObject * obj0 = 0 ;
29071 PyObject * obj1 = 0 ;
29072 char * kwnames[] = {
29073 (char *) "self",(char *) "format", NULL
29074 };
29075
29076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
29077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
29078 if (!SWIG_IsOK(res1)) {
29079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
29080 }
29081 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
29082 if (obj1) {
29083 {
29084 arg2 = wxString_in_helper(obj1);
29085 if (arg2 == NULL) SWIG_fail;
29086 temp2 = true;
29087 }
29088 }
29089 {
29090 PyThreadState* __tstate = wxPyBeginAllowThreads();
29091 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
29092 wxPyEndAllowThreads(__tstate);
29093 if (PyErr_Occurred()) SWIG_fail;
29094 }
29095 {
29096 #if wxUSE_UNICODE
29097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29098 #else
29099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29100 #endif
29101 }
29102 {
29103 if (temp2)
29104 delete arg2;
29105 }
29106 return resultobj;
29107 fail:
29108 {
29109 if (temp2)
29110 delete arg2;
29111 }
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29117 PyObject *obj;
29118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29119 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
29120 return SWIG_Py_Void();
29121 }
29122
29123 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29124 return SWIG_Python_InitShadowInstance(args);
29125 }
29126
29127 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29128 PyObject *resultobj = 0;
29129 int arg1 = (int) 0 ;
29130 int arg2 = (int) 0 ;
29131 int arg3 = (int) 0 ;
29132 int arg4 = (int) 0 ;
29133 wxDateSpan *result = 0 ;
29134 int val1 ;
29135 int ecode1 = 0 ;
29136 int val2 ;
29137 int ecode2 = 0 ;
29138 int val3 ;
29139 int ecode3 = 0 ;
29140 int val4 ;
29141 int ecode4 = 0 ;
29142 PyObject * obj0 = 0 ;
29143 PyObject * obj1 = 0 ;
29144 PyObject * obj2 = 0 ;
29145 PyObject * obj3 = 0 ;
29146 char * kwnames[] = {
29147 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
29148 };
29149
29150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29151 if (obj0) {
29152 ecode1 = SWIG_AsVal_int(obj0, &val1);
29153 if (!SWIG_IsOK(ecode1)) {
29154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
29155 }
29156 arg1 = static_cast< int >(val1);
29157 }
29158 if (obj1) {
29159 ecode2 = SWIG_AsVal_int(obj1, &val2);
29160 if (!SWIG_IsOK(ecode2)) {
29161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
29162 }
29163 arg2 = static_cast< int >(val2);
29164 }
29165 if (obj2) {
29166 ecode3 = SWIG_AsVal_int(obj2, &val3);
29167 if (!SWIG_IsOK(ecode3)) {
29168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
29169 }
29170 arg3 = static_cast< int >(val3);
29171 }
29172 if (obj3) {
29173 ecode4 = SWIG_AsVal_int(obj3, &val4);
29174 if (!SWIG_IsOK(ecode4)) {
29175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
29176 }
29177 arg4 = static_cast< int >(val4);
29178 }
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
29182 wxPyEndAllowThreads(__tstate);
29183 if (PyErr_Occurred()) SWIG_fail;
29184 }
29185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
29186 return resultobj;
29187 fail:
29188 return NULL;
29189 }
29190
29191
29192 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29193 PyObject *resultobj = 0;
29194 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29195 void *argp1 = 0 ;
29196 int res1 = 0 ;
29197 PyObject *swig_obj[1] ;
29198
29199 if (!args) SWIG_fail;
29200 swig_obj[0] = args;
29201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29202 if (!SWIG_IsOK(res1)) {
29203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29204 }
29205 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29206 {
29207 PyThreadState* __tstate = wxPyBeginAllowThreads();
29208 delete arg1;
29209
29210 wxPyEndAllowThreads(__tstate);
29211 if (PyErr_Occurred()) SWIG_fail;
29212 }
29213 resultobj = SWIG_Py_Void();
29214 return resultobj;
29215 fail:
29216 return NULL;
29217 }
29218
29219
29220 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29221 PyObject *resultobj = 0;
29222 int arg1 ;
29223 wxDateSpan result;
29224 int val1 ;
29225 int ecode1 = 0 ;
29226 PyObject * obj0 = 0 ;
29227 char * kwnames[] = {
29228 (char *) "days", NULL
29229 };
29230
29231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
29232 ecode1 = SWIG_AsVal_int(obj0, &val1);
29233 if (!SWIG_IsOK(ecode1)) {
29234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
29235 }
29236 arg1 = static_cast< int >(val1);
29237 {
29238 PyThreadState* __tstate = wxPyBeginAllowThreads();
29239 result = wxDateSpan::Days(arg1);
29240 wxPyEndAllowThreads(__tstate);
29241 if (PyErr_Occurred()) SWIG_fail;
29242 }
29243 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29244 return resultobj;
29245 fail:
29246 return NULL;
29247 }
29248
29249
29250 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29251 PyObject *resultobj = 0;
29252 wxDateSpan result;
29253
29254 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29255 {
29256 PyThreadState* __tstate = wxPyBeginAllowThreads();
29257 result = wxDateSpan::Day();
29258 wxPyEndAllowThreads(__tstate);
29259 if (PyErr_Occurred()) SWIG_fail;
29260 }
29261 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29262 return resultobj;
29263 fail:
29264 return NULL;
29265 }
29266
29267
29268 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29269 PyObject *resultobj = 0;
29270 int arg1 ;
29271 wxDateSpan result;
29272 int val1 ;
29273 int ecode1 = 0 ;
29274 PyObject * obj0 = 0 ;
29275 char * kwnames[] = {
29276 (char *) "weeks", NULL
29277 };
29278
29279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29280 ecode1 = SWIG_AsVal_int(obj0, &val1);
29281 if (!SWIG_IsOK(ecode1)) {
29282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29283 }
29284 arg1 = static_cast< int >(val1);
29285 {
29286 PyThreadState* __tstate = wxPyBeginAllowThreads();
29287 result = wxDateSpan::Weeks(arg1);
29288 wxPyEndAllowThreads(__tstate);
29289 if (PyErr_Occurred()) SWIG_fail;
29290 }
29291 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29292 return resultobj;
29293 fail:
29294 return NULL;
29295 }
29296
29297
29298 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29299 PyObject *resultobj = 0;
29300 wxDateSpan result;
29301
29302 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29303 {
29304 PyThreadState* __tstate = wxPyBeginAllowThreads();
29305 result = wxDateSpan::Week();
29306 wxPyEndAllowThreads(__tstate);
29307 if (PyErr_Occurred()) SWIG_fail;
29308 }
29309 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29310 return resultobj;
29311 fail:
29312 return NULL;
29313 }
29314
29315
29316 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29317 PyObject *resultobj = 0;
29318 int arg1 ;
29319 wxDateSpan result;
29320 int val1 ;
29321 int ecode1 = 0 ;
29322 PyObject * obj0 = 0 ;
29323 char * kwnames[] = {
29324 (char *) "mon", NULL
29325 };
29326
29327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29328 ecode1 = SWIG_AsVal_int(obj0, &val1);
29329 if (!SWIG_IsOK(ecode1)) {
29330 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29331 }
29332 arg1 = static_cast< int >(val1);
29333 {
29334 PyThreadState* __tstate = wxPyBeginAllowThreads();
29335 result = wxDateSpan::Months(arg1);
29336 wxPyEndAllowThreads(__tstate);
29337 if (PyErr_Occurred()) SWIG_fail;
29338 }
29339 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29347 PyObject *resultobj = 0;
29348 wxDateSpan result;
29349
29350 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 result = wxDateSpan::Month();
29354 wxPyEndAllowThreads(__tstate);
29355 if (PyErr_Occurred()) SWIG_fail;
29356 }
29357 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29365 PyObject *resultobj = 0;
29366 int arg1 ;
29367 wxDateSpan result;
29368 int val1 ;
29369 int ecode1 = 0 ;
29370 PyObject * obj0 = 0 ;
29371 char * kwnames[] = {
29372 (char *) "years", NULL
29373 };
29374
29375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29376 ecode1 = SWIG_AsVal_int(obj0, &val1);
29377 if (!SWIG_IsOK(ecode1)) {
29378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29379 }
29380 arg1 = static_cast< int >(val1);
29381 {
29382 PyThreadState* __tstate = wxPyBeginAllowThreads();
29383 result = wxDateSpan::Years(arg1);
29384 wxPyEndAllowThreads(__tstate);
29385 if (PyErr_Occurred()) SWIG_fail;
29386 }
29387 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29395 PyObject *resultobj = 0;
29396 wxDateSpan result;
29397
29398 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29399 {
29400 PyThreadState* __tstate = wxPyBeginAllowThreads();
29401 result = wxDateSpan::Year();
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29413 PyObject *resultobj = 0;
29414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29415 int arg2 ;
29416 wxDateSpan *result = 0 ;
29417 void *argp1 = 0 ;
29418 int res1 = 0 ;
29419 int val2 ;
29420 int ecode2 = 0 ;
29421 PyObject * obj0 = 0 ;
29422 PyObject * obj1 = 0 ;
29423 char * kwnames[] = {
29424 (char *) "self",(char *) "n", NULL
29425 };
29426
29427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29429 if (!SWIG_IsOK(res1)) {
29430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29431 }
29432 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29433 ecode2 = SWIG_AsVal_int(obj1, &val2);
29434 if (!SWIG_IsOK(ecode2)) {
29435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29436 }
29437 arg2 = static_cast< int >(val2);
29438 {
29439 PyThreadState* __tstate = wxPyBeginAllowThreads();
29440 {
29441 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29442 result = (wxDateSpan *) &_result_ref;
29443 }
29444 wxPyEndAllowThreads(__tstate);
29445 if (PyErr_Occurred()) SWIG_fail;
29446 }
29447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29448 return resultobj;
29449 fail:
29450 return NULL;
29451 }
29452
29453
29454 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29455 PyObject *resultobj = 0;
29456 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29457 int arg2 ;
29458 wxDateSpan *result = 0 ;
29459 void *argp1 = 0 ;
29460 int res1 = 0 ;
29461 int val2 ;
29462 int ecode2 = 0 ;
29463 PyObject * obj0 = 0 ;
29464 PyObject * obj1 = 0 ;
29465 char * kwnames[] = {
29466 (char *) "self",(char *) "n", NULL
29467 };
29468
29469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29471 if (!SWIG_IsOK(res1)) {
29472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29473 }
29474 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29475 ecode2 = SWIG_AsVal_int(obj1, &val2);
29476 if (!SWIG_IsOK(ecode2)) {
29477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29478 }
29479 arg2 = static_cast< int >(val2);
29480 {
29481 PyThreadState* __tstate = wxPyBeginAllowThreads();
29482 {
29483 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29484 result = (wxDateSpan *) &_result_ref;
29485 }
29486 wxPyEndAllowThreads(__tstate);
29487 if (PyErr_Occurred()) SWIG_fail;
29488 }
29489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29497 PyObject *resultobj = 0;
29498 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29499 int arg2 ;
29500 wxDateSpan *result = 0 ;
29501 void *argp1 = 0 ;
29502 int res1 = 0 ;
29503 int val2 ;
29504 int ecode2 = 0 ;
29505 PyObject * obj0 = 0 ;
29506 PyObject * obj1 = 0 ;
29507 char * kwnames[] = {
29508 (char *) "self",(char *) "n", NULL
29509 };
29510
29511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29513 if (!SWIG_IsOK(res1)) {
29514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29515 }
29516 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29517 ecode2 = SWIG_AsVal_int(obj1, &val2);
29518 if (!SWIG_IsOK(ecode2)) {
29519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29520 }
29521 arg2 = static_cast< int >(val2);
29522 {
29523 PyThreadState* __tstate = wxPyBeginAllowThreads();
29524 {
29525 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29526 result = (wxDateSpan *) &_result_ref;
29527 }
29528 wxPyEndAllowThreads(__tstate);
29529 if (PyErr_Occurred()) SWIG_fail;
29530 }
29531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29532 return resultobj;
29533 fail:
29534 return NULL;
29535 }
29536
29537
29538 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29539 PyObject *resultobj = 0;
29540 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29541 int arg2 ;
29542 wxDateSpan *result = 0 ;
29543 void *argp1 = 0 ;
29544 int res1 = 0 ;
29545 int val2 ;
29546 int ecode2 = 0 ;
29547 PyObject * obj0 = 0 ;
29548 PyObject * obj1 = 0 ;
29549 char * kwnames[] = {
29550 (char *) "self",(char *) "n", NULL
29551 };
29552
29553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29555 if (!SWIG_IsOK(res1)) {
29556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29557 }
29558 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29559 ecode2 = SWIG_AsVal_int(obj1, &val2);
29560 if (!SWIG_IsOK(ecode2)) {
29561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29562 }
29563 arg2 = static_cast< int >(val2);
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 {
29567 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29568 result = (wxDateSpan *) &_result_ref;
29569 }
29570 wxPyEndAllowThreads(__tstate);
29571 if (PyErr_Occurred()) SWIG_fail;
29572 }
29573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29574 return resultobj;
29575 fail:
29576 return NULL;
29577 }
29578
29579
29580 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29581 PyObject *resultobj = 0;
29582 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29583 int result;
29584 void *argp1 = 0 ;
29585 int res1 = 0 ;
29586 PyObject *swig_obj[1] ;
29587
29588 if (!args) SWIG_fail;
29589 swig_obj[0] = args;
29590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29591 if (!SWIG_IsOK(res1)) {
29592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29593 }
29594 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29595 {
29596 PyThreadState* __tstate = wxPyBeginAllowThreads();
29597 result = (int)((wxDateSpan const *)arg1)->GetYears();
29598 wxPyEndAllowThreads(__tstate);
29599 if (PyErr_Occurred()) SWIG_fail;
29600 }
29601 resultobj = SWIG_From_int(static_cast< int >(result));
29602 return resultobj;
29603 fail:
29604 return NULL;
29605 }
29606
29607
29608 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29609 PyObject *resultobj = 0;
29610 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29611 int result;
29612 void *argp1 = 0 ;
29613 int res1 = 0 ;
29614 PyObject *swig_obj[1] ;
29615
29616 if (!args) SWIG_fail;
29617 swig_obj[0] = args;
29618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29619 if (!SWIG_IsOK(res1)) {
29620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29621 }
29622 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29623 {
29624 PyThreadState* __tstate = wxPyBeginAllowThreads();
29625 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29626 wxPyEndAllowThreads(__tstate);
29627 if (PyErr_Occurred()) SWIG_fail;
29628 }
29629 resultobj = SWIG_From_int(static_cast< int >(result));
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29637 PyObject *resultobj = 0;
29638 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29639 int result;
29640 void *argp1 = 0 ;
29641 int res1 = 0 ;
29642 PyObject *swig_obj[1] ;
29643
29644 if (!args) SWIG_fail;
29645 swig_obj[0] = args;
29646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29647 if (!SWIG_IsOK(res1)) {
29648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29649 }
29650 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29651 {
29652 PyThreadState* __tstate = wxPyBeginAllowThreads();
29653 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29654 wxPyEndAllowThreads(__tstate);
29655 if (PyErr_Occurred()) SWIG_fail;
29656 }
29657 resultobj = SWIG_From_int(static_cast< int >(result));
29658 return resultobj;
29659 fail:
29660 return NULL;
29661 }
29662
29663
29664 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29665 PyObject *resultobj = 0;
29666 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29667 int result;
29668 void *argp1 = 0 ;
29669 int res1 = 0 ;
29670 PyObject *swig_obj[1] ;
29671
29672 if (!args) SWIG_fail;
29673 swig_obj[0] = args;
29674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29677 }
29678 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = (int)((wxDateSpan const *)arg1)->GetDays();
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 resultobj = SWIG_From_int(static_cast< int >(result));
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29693 PyObject *resultobj = 0;
29694 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29695 int result;
29696 void *argp1 = 0 ;
29697 int res1 = 0 ;
29698 PyObject *swig_obj[1] ;
29699
29700 if (!args) SWIG_fail;
29701 swig_obj[0] = args;
29702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29703 if (!SWIG_IsOK(res1)) {
29704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29705 }
29706 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29707 {
29708 PyThreadState* __tstate = wxPyBeginAllowThreads();
29709 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29710 wxPyEndAllowThreads(__tstate);
29711 if (PyErr_Occurred()) SWIG_fail;
29712 }
29713 resultobj = SWIG_From_int(static_cast< int >(result));
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29721 PyObject *resultobj = 0;
29722 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29723 wxDateSpan *arg2 = 0 ;
29724 wxDateSpan *result = 0 ;
29725 void *argp1 = 0 ;
29726 int res1 = 0 ;
29727 void *argp2 = 0 ;
29728 int res2 = 0 ;
29729 PyObject * obj0 = 0 ;
29730 PyObject * obj1 = 0 ;
29731 char * kwnames[] = {
29732 (char *) "self",(char *) "other", NULL
29733 };
29734
29735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29737 if (!SWIG_IsOK(res1)) {
29738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29739 }
29740 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29741 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29742 if (!SWIG_IsOK(res2)) {
29743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29744 }
29745 if (!argp2) {
29746 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29747 }
29748 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29749 {
29750 PyThreadState* __tstate = wxPyBeginAllowThreads();
29751 {
29752 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29753 result = (wxDateSpan *) &_result_ref;
29754 }
29755 wxPyEndAllowThreads(__tstate);
29756 if (PyErr_Occurred()) SWIG_fail;
29757 }
29758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29759 return resultobj;
29760 fail:
29761 return NULL;
29762 }
29763
29764
29765 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29766 PyObject *resultobj = 0;
29767 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29768 wxDateSpan *arg2 = 0 ;
29769 wxDateSpan *result = 0 ;
29770 void *argp1 = 0 ;
29771 int res1 = 0 ;
29772 void *argp2 = 0 ;
29773 int res2 = 0 ;
29774 PyObject * obj0 = 0 ;
29775 PyObject * obj1 = 0 ;
29776 char * kwnames[] = {
29777 (char *) "self",(char *) "other", NULL
29778 };
29779
29780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29782 if (!SWIG_IsOK(res1)) {
29783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29784 }
29785 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29786 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29787 if (!SWIG_IsOK(res2)) {
29788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29789 }
29790 if (!argp2) {
29791 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29792 }
29793 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29794 {
29795 PyThreadState* __tstate = wxPyBeginAllowThreads();
29796 {
29797 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29798 result = (wxDateSpan *) &_result_ref;
29799 }
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29804 return resultobj;
29805 fail:
29806 return NULL;
29807 }
29808
29809
29810 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29811 PyObject *resultobj = 0;
29812 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29813 wxDateSpan *result = 0 ;
29814 void *argp1 = 0 ;
29815 int res1 = 0 ;
29816 PyObject *swig_obj[1] ;
29817
29818 if (!args) SWIG_fail;
29819 swig_obj[0] = args;
29820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29821 if (!SWIG_IsOK(res1)) {
29822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29823 }
29824 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 {
29828 wxDateSpan &_result_ref = (arg1)->Neg();
29829 result = (wxDateSpan *) &_result_ref;
29830 }
29831 wxPyEndAllowThreads(__tstate);
29832 if (PyErr_Occurred()) SWIG_fail;
29833 }
29834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29835 return resultobj;
29836 fail:
29837 return NULL;
29838 }
29839
29840
29841 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29842 PyObject *resultobj = 0;
29843 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29844 int arg2 ;
29845 wxDateSpan *result = 0 ;
29846 void *argp1 = 0 ;
29847 int res1 = 0 ;
29848 int val2 ;
29849 int ecode2 = 0 ;
29850 PyObject * obj0 = 0 ;
29851 PyObject * obj1 = 0 ;
29852 char * kwnames[] = {
29853 (char *) "self",(char *) "factor", NULL
29854 };
29855
29856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29858 if (!SWIG_IsOK(res1)) {
29859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29860 }
29861 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29862 ecode2 = SWIG_AsVal_int(obj1, &val2);
29863 if (!SWIG_IsOK(ecode2)) {
29864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29865 }
29866 arg2 = static_cast< int >(val2);
29867 {
29868 PyThreadState* __tstate = wxPyBeginAllowThreads();
29869 {
29870 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29871 result = (wxDateSpan *) &_result_ref;
29872 }
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj = 0;
29885 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29886 wxDateSpan *arg2 = 0 ;
29887 wxDateSpan *result = 0 ;
29888 void *argp1 = 0 ;
29889 int res1 = 0 ;
29890 void *argp2 = 0 ;
29891 int res2 = 0 ;
29892 PyObject * obj0 = 0 ;
29893 PyObject * obj1 = 0 ;
29894 char * kwnames[] = {
29895 (char *) "self",(char *) "other", NULL
29896 };
29897
29898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29900 if (!SWIG_IsOK(res1)) {
29901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29902 }
29903 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29905 if (!SWIG_IsOK(res2)) {
29906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29907 }
29908 if (!argp2) {
29909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29910 }
29911 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 {
29915 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29916 result = (wxDateSpan *) &_result_ref;
29917 }
29918 wxPyEndAllowThreads(__tstate);
29919 if (PyErr_Occurred()) SWIG_fail;
29920 }
29921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29922 return resultobj;
29923 fail:
29924 return NULL;
29925 }
29926
29927
29928 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29929 PyObject *resultobj = 0;
29930 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29931 wxDateSpan *arg2 = 0 ;
29932 wxDateSpan *result = 0 ;
29933 void *argp1 = 0 ;
29934 int res1 = 0 ;
29935 void *argp2 = 0 ;
29936 int res2 = 0 ;
29937 PyObject * obj0 = 0 ;
29938 PyObject * obj1 = 0 ;
29939 char * kwnames[] = {
29940 (char *) "self",(char *) "other", NULL
29941 };
29942
29943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29945 if (!SWIG_IsOK(res1)) {
29946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29947 }
29948 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29950 if (!SWIG_IsOK(res2)) {
29951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29952 }
29953 if (!argp2) {
29954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29955 }
29956 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29957 {
29958 PyThreadState* __tstate = wxPyBeginAllowThreads();
29959 {
29960 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29961 result = (wxDateSpan *) &_result_ref;
29962 }
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29967 return resultobj;
29968 fail:
29969 return NULL;
29970 }
29971
29972
29973 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29974 PyObject *resultobj = 0;
29975 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29976 wxDateSpan *result = 0 ;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 PyObject *swig_obj[1] ;
29980
29981 if (!args) SWIG_fail;
29982 swig_obj[0] = args;
29983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29986 }
29987 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29988 {
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 {
29991 wxDateSpan &_result_ref = (arg1)->operator -();
29992 result = (wxDateSpan *) &_result_ref;
29993 }
29994 wxPyEndAllowThreads(__tstate);
29995 if (PyErr_Occurred()) SWIG_fail;
29996 }
29997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29998 return resultobj;
29999 fail:
30000 return NULL;
30001 }
30002
30003
30004 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30005 PyObject *resultobj = 0;
30006 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30007 int arg2 ;
30008 wxDateSpan *result = 0 ;
30009 void *argp1 = 0 ;
30010 int res1 = 0 ;
30011 int val2 ;
30012 int ecode2 = 0 ;
30013 PyObject * obj0 = 0 ;
30014 PyObject * obj1 = 0 ;
30015 char * kwnames[] = {
30016 (char *) "self",(char *) "factor", NULL
30017 };
30018
30019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
30020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
30021 if (!SWIG_IsOK(res1)) {
30022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30023 }
30024 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30025 ecode2 = SWIG_AsVal_int(obj1, &val2);
30026 if (!SWIG_IsOK(ecode2)) {
30027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
30028 }
30029 arg2 = static_cast< int >(val2);
30030 {
30031 PyThreadState* __tstate = wxPyBeginAllowThreads();
30032 {
30033 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
30034 result = (wxDateSpan *) &_result_ref;
30035 }
30036 wxPyEndAllowThreads(__tstate);
30037 if (PyErr_Occurred()) SWIG_fail;
30038 }
30039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30040 return resultobj;
30041 fail:
30042 return NULL;
30043 }
30044
30045
30046 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30047 PyObject *resultobj = 0;
30048 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30049 wxDateSpan *arg2 = 0 ;
30050 wxDateSpan result;
30051 void *argp1 = 0 ;
30052 int res1 = 0 ;
30053 void *argp2 = 0 ;
30054 int res2 = 0 ;
30055 PyObject * obj0 = 0 ;
30056 PyObject * obj1 = 0 ;
30057 char * kwnames[] = {
30058 (char *) "self",(char *) "other", NULL
30059 };
30060
30061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
30062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30063 if (!SWIG_IsOK(res1)) {
30064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30065 }
30066 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30068 if (!SWIG_IsOK(res2)) {
30069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30070 }
30071 if (!argp2) {
30072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30073 }
30074 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30075 {
30076 PyThreadState* __tstate = wxPyBeginAllowThreads();
30077 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
30078 wxPyEndAllowThreads(__tstate);
30079 if (PyErr_Occurred()) SWIG_fail;
30080 }
30081 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30089 PyObject *resultobj = 0;
30090 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30091 wxDateSpan *arg2 = 0 ;
30092 wxDateSpan result;
30093 void *argp1 = 0 ;
30094 int res1 = 0 ;
30095 void *argp2 = 0 ;
30096 int res2 = 0 ;
30097 PyObject * obj0 = 0 ;
30098 PyObject * obj1 = 0 ;
30099 char * kwnames[] = {
30100 (char *) "self",(char *) "other", NULL
30101 };
30102
30103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
30104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30105 if (!SWIG_IsOK(res1)) {
30106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30107 }
30108 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30109 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
30110 if (!SWIG_IsOK(res2)) {
30111 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30112 }
30113 if (!argp2) {
30114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
30115 }
30116 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30117 {
30118 PyThreadState* __tstate = wxPyBeginAllowThreads();
30119 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
30120 wxPyEndAllowThreads(__tstate);
30121 if (PyErr_Occurred()) SWIG_fail;
30122 }
30123 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30124 return resultobj;
30125 fail:
30126 return NULL;
30127 }
30128
30129
30130 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30131 PyObject *resultobj = 0;
30132 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30133 int arg2 ;
30134 wxDateSpan result;
30135 void *argp1 = 0 ;
30136 int res1 = 0 ;
30137 int val2 ;
30138 int ecode2 = 0 ;
30139 PyObject * obj0 = 0 ;
30140 PyObject * obj1 = 0 ;
30141 char * kwnames[] = {
30142 (char *) "self",(char *) "n", NULL
30143 };
30144
30145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
30146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30147 if (!SWIG_IsOK(res1)) {
30148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30149 }
30150 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30151 ecode2 = SWIG_AsVal_int(obj1, &val2);
30152 if (!SWIG_IsOK(ecode2)) {
30153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
30154 }
30155 arg2 = static_cast< int >(val2);
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 result = wxDateSpan___mul__(arg1,arg2);
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj = 0;
30171 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30172 int arg2 ;
30173 wxDateSpan result;
30174 void *argp1 = 0 ;
30175 int res1 = 0 ;
30176 int val2 ;
30177 int ecode2 = 0 ;
30178 PyObject * obj0 = 0 ;
30179 PyObject * obj1 = 0 ;
30180 char * kwnames[] = {
30181 (char *) "self",(char *) "n", NULL
30182 };
30183
30184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
30185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30186 if (!SWIG_IsOK(res1)) {
30187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30188 }
30189 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30190 ecode2 = SWIG_AsVal_int(obj1, &val2);
30191 if (!SWIG_IsOK(ecode2)) {
30192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
30193 }
30194 arg2 = static_cast< int >(val2);
30195 {
30196 PyThreadState* __tstate = wxPyBeginAllowThreads();
30197 result = wxDateSpan___rmul__(arg1,arg2);
30198 wxPyEndAllowThreads(__tstate);
30199 if (PyErr_Occurred()) SWIG_fail;
30200 }
30201 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
30202 return resultobj;
30203 fail:
30204 return NULL;
30205 }
30206
30207
30208 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30209 PyObject *resultobj = 0;
30210 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30211 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30212 bool result;
30213 void *argp1 = 0 ;
30214 int res1 = 0 ;
30215 void *argp2 = 0 ;
30216 int res2 = 0 ;
30217 PyObject * obj0 = 0 ;
30218 PyObject * obj1 = 0 ;
30219 char * kwnames[] = {
30220 (char *) "self",(char *) "other", NULL
30221 };
30222
30223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
30224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30225 if (!SWIG_IsOK(res1)) {
30226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30227 }
30228 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30230 if (!SWIG_IsOK(res2)) {
30231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30232 }
30233 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
30237 wxPyEndAllowThreads(__tstate);
30238 if (PyErr_Occurred()) SWIG_fail;
30239 }
30240 {
30241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30242 }
30243 return resultobj;
30244 fail:
30245 return NULL;
30246 }
30247
30248
30249 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30250 PyObject *resultobj = 0;
30251 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30252 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30253 bool result;
30254 void *argp1 = 0 ;
30255 int res1 = 0 ;
30256 void *argp2 = 0 ;
30257 int res2 = 0 ;
30258 PyObject * obj0 = 0 ;
30259 PyObject * obj1 = 0 ;
30260 char * kwnames[] = {
30261 (char *) "self",(char *) "other", NULL
30262 };
30263
30264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30266 if (!SWIG_IsOK(res1)) {
30267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30268 }
30269 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30271 if (!SWIG_IsOK(res2)) {
30272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30273 }
30274 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 {
30282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30283 }
30284 return resultobj;
30285 fail:
30286 return NULL;
30287 }
30288
30289
30290 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30291 PyObject *obj;
30292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30293 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30294 return SWIG_Py_Void();
30295 }
30296
30297 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30298 return SWIG_Python_InitShadowInstance(args);
30299 }
30300
30301 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30302 PyObject *resultobj = 0;
30303 long result;
30304
30305 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30306 {
30307 PyThreadState* __tstate = wxPyBeginAllowThreads();
30308 result = (long)wxGetLocalTime();
30309 wxPyEndAllowThreads(__tstate);
30310 if (PyErr_Occurred()) SWIG_fail;
30311 }
30312 resultobj = SWIG_From_long(static_cast< long >(result));
30313 return resultobj;
30314 fail:
30315 return NULL;
30316 }
30317
30318
30319 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30320 PyObject *resultobj = 0;
30321 long result;
30322
30323 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30324 {
30325 PyThreadState* __tstate = wxPyBeginAllowThreads();
30326 result = (long)wxGetUTCTime();
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 resultobj = SWIG_From_long(static_cast< long >(result));
30331 return resultobj;
30332 fail:
30333 return NULL;
30334 }
30335
30336
30337 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30338 PyObject *resultobj = 0;
30339 long result;
30340
30341 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30342 {
30343 PyThreadState* __tstate = wxPyBeginAllowThreads();
30344 result = (long)wxGetCurrentTime();
30345 wxPyEndAllowThreads(__tstate);
30346 if (PyErr_Occurred()) SWIG_fail;
30347 }
30348 resultobj = SWIG_From_long(static_cast< long >(result));
30349 return resultobj;
30350 fail:
30351 return NULL;
30352 }
30353
30354
30355 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30356 PyObject *resultobj = 0;
30357 wxLongLong result;
30358
30359 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 result = wxGetLocalTimeMillis();
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 {
30367 PyObject *hi, *lo, *shifter, *shifted;
30368 hi = PyLong_FromLong( (&result)->GetHi() );
30369 lo = PyLong_FromLong( (&result)->GetLo() );
30370 shifter = PyLong_FromLong(32);
30371 shifted = PyNumber_Lshift(hi, shifter);
30372 resultobj = PyNumber_Or(shifted, lo);
30373 Py_DECREF(hi);
30374 Py_DECREF(lo);
30375 Py_DECREF(shifter);
30376 Py_DECREF(shifted);
30377 }
30378 return resultobj;
30379 fail:
30380 return NULL;
30381 }
30382
30383
30384 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30385 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30386 return 1;
30387 }
30388
30389
30390 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30391 PyObject *pyobj = 0;
30392
30393 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30394 return pyobj;
30395 }
30396
30397
30398 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30399 PyObject *resultobj = 0;
30400 wxDataFormatId arg1 ;
30401 wxDataFormat *result = 0 ;
30402 int val1 ;
30403 int ecode1 = 0 ;
30404 PyObject * obj0 = 0 ;
30405 char * kwnames[] = {
30406 (char *) "type", NULL
30407 };
30408
30409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30410 ecode1 = SWIG_AsVal_int(obj0, &val1);
30411 if (!SWIG_IsOK(ecode1)) {
30412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30413 }
30414 arg1 = static_cast< wxDataFormatId >(val1);
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 result = (wxDataFormat *)new wxDataFormat(arg1);
30418 wxPyEndAllowThreads(__tstate);
30419 if (PyErr_Occurred()) SWIG_fail;
30420 }
30421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30422 return resultobj;
30423 fail:
30424 return NULL;
30425 }
30426
30427
30428 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30429 PyObject *resultobj = 0;
30430 wxString *arg1 = 0 ;
30431 wxDataFormat *result = 0 ;
30432 bool temp1 = false ;
30433 PyObject * obj0 = 0 ;
30434 char * kwnames[] = {
30435 (char *) "format", NULL
30436 };
30437
30438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30439 {
30440 arg1 = wxString_in_helper(obj0);
30441 if (arg1 == NULL) SWIG_fail;
30442 temp1 = true;
30443 }
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30451 {
30452 if (temp1)
30453 delete arg1;
30454 }
30455 return resultobj;
30456 fail:
30457 {
30458 if (temp1)
30459 delete arg1;
30460 }
30461 return NULL;
30462 }
30463
30464
30465 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30466 PyObject *resultobj = 0;
30467 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30468 void *argp1 = 0 ;
30469 int res1 = 0 ;
30470 PyObject *swig_obj[1] ;
30471
30472 if (!args) SWIG_fail;
30473 swig_obj[0] = args;
30474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30475 if (!SWIG_IsOK(res1)) {
30476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30477 }
30478 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30479 {
30480 PyThreadState* __tstate = wxPyBeginAllowThreads();
30481 delete arg1;
30482
30483 wxPyEndAllowThreads(__tstate);
30484 if (PyErr_Occurred()) SWIG_fail;
30485 }
30486 resultobj = SWIG_Py_Void();
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30494 PyObject *resultobj = 0;
30495 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30496 wxDataFormatId arg2 ;
30497 bool result;
30498 void *argp1 = 0 ;
30499 int res1 = 0 ;
30500 int val2 ;
30501 int ecode2 = 0 ;
30502
30503 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30505 if (!SWIG_IsOK(res1)) {
30506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30507 }
30508 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30509 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30510 if (!SWIG_IsOK(ecode2)) {
30511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30512 }
30513 arg2 = static_cast< wxDataFormatId >(val2);
30514 {
30515 PyThreadState* __tstate = wxPyBeginAllowThreads();
30516 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30517 wxPyEndAllowThreads(__tstate);
30518 if (PyErr_Occurred()) SWIG_fail;
30519 }
30520 {
30521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30522 }
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30530 PyObject *resultobj = 0;
30531 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30532 wxDataFormatId arg2 ;
30533 bool result;
30534 void *argp1 = 0 ;
30535 int res1 = 0 ;
30536 int val2 ;
30537 int ecode2 = 0 ;
30538
30539 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30541 if (!SWIG_IsOK(res1)) {
30542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30543 }
30544 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30545 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30546 if (!SWIG_IsOK(ecode2)) {
30547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30548 }
30549 arg2 = static_cast< wxDataFormatId >(val2);
30550 {
30551 PyThreadState* __tstate = wxPyBeginAllowThreads();
30552 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30553 wxPyEndAllowThreads(__tstate);
30554 if (PyErr_Occurred()) SWIG_fail;
30555 }
30556 {
30557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30558 }
30559 return resultobj;
30560 fail:
30561 return NULL;
30562 }
30563
30564
30565 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30566 PyObject *resultobj = 0;
30567 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30568 wxDataFormat *arg2 = 0 ;
30569 bool result;
30570 void *argp1 = 0 ;
30571 int res1 = 0 ;
30572 void *argp2 = 0 ;
30573 int res2 = 0 ;
30574
30575 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30577 if (!SWIG_IsOK(res1)) {
30578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30579 }
30580 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30581 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30582 if (!SWIG_IsOK(res2)) {
30583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30584 }
30585 if (!argp2) {
30586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30587 }
30588 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30589 {
30590 PyThreadState* __tstate = wxPyBeginAllowThreads();
30591 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30592 wxPyEndAllowThreads(__tstate);
30593 if (PyErr_Occurred()) SWIG_fail;
30594 }
30595 {
30596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30597 }
30598 return resultobj;
30599 fail:
30600 return NULL;
30601 }
30602
30603
30604 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30605 int argc;
30606 PyObject *argv[3];
30607
30608 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30609 --argc;
30610 if (argc == 2) {
30611 int _v = 0;
30612 {
30613 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30614 _v = SWIG_CheckState(res);
30615 }
30616 if (!_v) goto check_1;
30617 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30618 }
30619 check_1:
30620
30621 if (argc == 2) {
30622 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30623 }
30624
30625 fail:
30626 Py_INCREF(Py_NotImplemented);
30627 return Py_NotImplemented;
30628 }
30629
30630
30631 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30632 PyObject *resultobj = 0;
30633 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30634 wxDataFormat *arg2 = 0 ;
30635 bool result;
30636 void *argp1 = 0 ;
30637 int res1 = 0 ;
30638 void *argp2 = 0 ;
30639 int res2 = 0 ;
30640
30641 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30643 if (!SWIG_IsOK(res1)) {
30644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30645 }
30646 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30647 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30648 if (!SWIG_IsOK(res2)) {
30649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30650 }
30651 if (!argp2) {
30652 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30653 }
30654 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30655 {
30656 PyThreadState* __tstate = wxPyBeginAllowThreads();
30657 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30658 wxPyEndAllowThreads(__tstate);
30659 if (PyErr_Occurred()) SWIG_fail;
30660 }
30661 {
30662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30663 }
30664 return resultobj;
30665 fail:
30666 return NULL;
30667 }
30668
30669
30670 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30671 int argc;
30672 PyObject *argv[3];
30673
30674 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30675 --argc;
30676 if (argc == 2) {
30677 int _v = 0;
30678 {
30679 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30680 _v = SWIG_CheckState(res);
30681 }
30682 if (!_v) goto check_1;
30683 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30684 }
30685 check_1:
30686
30687 if (argc == 2) {
30688 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30689 }
30690
30691 fail:
30692 Py_INCREF(Py_NotImplemented);
30693 return Py_NotImplemented;
30694 }
30695
30696
30697 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30698 PyObject *resultobj = 0;
30699 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30700 wxDataFormatId arg2 ;
30701 void *argp1 = 0 ;
30702 int res1 = 0 ;
30703 int val2 ;
30704 int ecode2 = 0 ;
30705 PyObject * obj0 = 0 ;
30706 PyObject * obj1 = 0 ;
30707 char * kwnames[] = {
30708 (char *) "self",(char *) "format", NULL
30709 };
30710
30711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30713 if (!SWIG_IsOK(res1)) {
30714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30715 }
30716 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30717 ecode2 = SWIG_AsVal_int(obj1, &val2);
30718 if (!SWIG_IsOK(ecode2)) {
30719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30720 }
30721 arg2 = static_cast< wxDataFormatId >(val2);
30722 {
30723 PyThreadState* __tstate = wxPyBeginAllowThreads();
30724 (arg1)->SetType(arg2);
30725 wxPyEndAllowThreads(__tstate);
30726 if (PyErr_Occurred()) SWIG_fail;
30727 }
30728 resultobj = SWIG_Py_Void();
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30736 PyObject *resultobj = 0;
30737 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30738 wxDataFormatId result;
30739 void *argp1 = 0 ;
30740 int res1 = 0 ;
30741 PyObject *swig_obj[1] ;
30742
30743 if (!args) SWIG_fail;
30744 swig_obj[0] = args;
30745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30748 }
30749 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 resultobj = SWIG_From_int(static_cast< int >(result));
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30764 PyObject *resultobj = 0;
30765 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30766 wxString result;
30767 void *argp1 = 0 ;
30768 int res1 = 0 ;
30769 PyObject *swig_obj[1] ;
30770
30771 if (!args) SWIG_fail;
30772 swig_obj[0] = args;
30773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30774 if (!SWIG_IsOK(res1)) {
30775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30776 }
30777 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = ((wxDataFormat const *)arg1)->GetId();
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 {
30785 #if wxUSE_UNICODE
30786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30787 #else
30788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30789 #endif
30790 }
30791 return resultobj;
30792 fail:
30793 return NULL;
30794 }
30795
30796
30797 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30798 PyObject *resultobj = 0;
30799 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30800 wxString *arg2 = 0 ;
30801 void *argp1 = 0 ;
30802 int res1 = 0 ;
30803 bool temp2 = false ;
30804 PyObject * obj0 = 0 ;
30805 PyObject * obj1 = 0 ;
30806 char * kwnames[] = {
30807 (char *) "self",(char *) "format", NULL
30808 };
30809
30810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30812 if (!SWIG_IsOK(res1)) {
30813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30814 }
30815 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30816 {
30817 arg2 = wxString_in_helper(obj1);
30818 if (arg2 == NULL) SWIG_fail;
30819 temp2 = true;
30820 }
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 (arg1)->SetId((wxString const &)*arg2);
30824 wxPyEndAllowThreads(__tstate);
30825 if (PyErr_Occurred()) SWIG_fail;
30826 }
30827 resultobj = SWIG_Py_Void();
30828 {
30829 if (temp2)
30830 delete arg2;
30831 }
30832 return resultobj;
30833 fail:
30834 {
30835 if (temp2)
30836 delete arg2;
30837 }
30838 return NULL;
30839 }
30840
30841
30842 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30843 PyObject *obj;
30844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30845 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30846 return SWIG_Py_Void();
30847 }
30848
30849 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30850 return SWIG_Python_InitShadowInstance(args);
30851 }
30852
30853 SWIGINTERN int FormatInvalid_set(PyObject *) {
30854 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30855 return 1;
30856 }
30857
30858
30859 SWIGINTERN PyObject *FormatInvalid_get(void) {
30860 PyObject *pyobj = 0;
30861
30862 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30863 return pyobj;
30864 }
30865
30866
30867 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30868 PyObject *resultobj = 0;
30869 wxDataObject *arg1 = (wxDataObject *) 0 ;
30870 void *argp1 = 0 ;
30871 int res1 = 0 ;
30872 PyObject *swig_obj[1] ;
30873
30874 if (!args) SWIG_fail;
30875 swig_obj[0] = args;
30876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30877 if (!SWIG_IsOK(res1)) {
30878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30879 }
30880 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 delete arg1;
30884
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 resultobj = SWIG_Py_Void();
30889 return resultobj;
30890 fail:
30891 return NULL;
30892 }
30893
30894
30895 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30896 PyObject *resultobj = 0;
30897 wxDataObject *arg1 = (wxDataObject *) 0 ;
30898 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30899 SwigValueWrapper<wxDataFormat > result;
30900 void *argp1 = 0 ;
30901 int res1 = 0 ;
30902 int val2 ;
30903 int ecode2 = 0 ;
30904 PyObject * obj0 = 0 ;
30905 PyObject * obj1 = 0 ;
30906 char * kwnames[] = {
30907 (char *) "self",(char *) "dir", NULL
30908 };
30909
30910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30912 if (!SWIG_IsOK(res1)) {
30913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30914 }
30915 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30916 if (obj1) {
30917 ecode2 = SWIG_AsVal_int(obj1, &val2);
30918 if (!SWIG_IsOK(ecode2)) {
30919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30920 }
30921 arg2 = static_cast< wxDataObject::Direction >(val2);
30922 }
30923 {
30924 PyThreadState* __tstate = wxPyBeginAllowThreads();
30925 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30926 wxPyEndAllowThreads(__tstate);
30927 if (PyErr_Occurred()) SWIG_fail;
30928 }
30929 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj = 0;
30938 wxDataObject *arg1 = (wxDataObject *) 0 ;
30939 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30940 size_t result;
30941 void *argp1 = 0 ;
30942 int res1 = 0 ;
30943 int val2 ;
30944 int ecode2 = 0 ;
30945 PyObject * obj0 = 0 ;
30946 PyObject * obj1 = 0 ;
30947 char * kwnames[] = {
30948 (char *) "self",(char *) "dir", NULL
30949 };
30950
30951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30953 if (!SWIG_IsOK(res1)) {
30954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30955 }
30956 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30957 if (obj1) {
30958 ecode2 = SWIG_AsVal_int(obj1, &val2);
30959 if (!SWIG_IsOK(ecode2)) {
30960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30961 }
30962 arg2 = static_cast< wxDataObject::Direction >(val2);
30963 }
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30971 return resultobj;
30972 fail:
30973 return NULL;
30974 }
30975
30976
30977 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30978 PyObject *resultobj = 0;
30979 wxDataObject *arg1 = (wxDataObject *) 0 ;
30980 wxDataFormat *arg2 = 0 ;
30981 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30982 bool result;
30983 void *argp1 = 0 ;
30984 int res1 = 0 ;
30985 void *argp2 = 0 ;
30986 int res2 = 0 ;
30987 int val3 ;
30988 int ecode3 = 0 ;
30989 PyObject * obj0 = 0 ;
30990 PyObject * obj1 = 0 ;
30991 PyObject * obj2 = 0 ;
30992 char * kwnames[] = {
30993 (char *) "self",(char *) "format",(char *) "dir", NULL
30994 };
30995
30996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30998 if (!SWIG_IsOK(res1)) {
30999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31000 }
31001 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31002 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31003 if (!SWIG_IsOK(res2)) {
31004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31005 }
31006 if (!argp2) {
31007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31008 }
31009 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31010 if (obj2) {
31011 ecode3 = SWIG_AsVal_int(obj2, &val3);
31012 if (!SWIG_IsOK(ecode3)) {
31013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
31014 }
31015 arg3 = static_cast< wxDataObject::Direction >(val3);
31016 }
31017 {
31018 PyThreadState* __tstate = wxPyBeginAllowThreads();
31019 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
31020 wxPyEndAllowThreads(__tstate);
31021 if (PyErr_Occurred()) SWIG_fail;
31022 }
31023 {
31024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31025 }
31026 return resultobj;
31027 fail:
31028 return NULL;
31029 }
31030
31031
31032 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31033 PyObject *resultobj = 0;
31034 wxDataObject *arg1 = (wxDataObject *) 0 ;
31035 wxDataFormat *arg2 = 0 ;
31036 size_t result;
31037 void *argp1 = 0 ;
31038 int res1 = 0 ;
31039 void *argp2 = 0 ;
31040 int res2 = 0 ;
31041 PyObject * obj0 = 0 ;
31042 PyObject * obj1 = 0 ;
31043 char * kwnames[] = {
31044 (char *) "self",(char *) "format", NULL
31045 };
31046
31047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
31048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31049 if (!SWIG_IsOK(res1)) {
31050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
31051 }
31052 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31053 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31054 if (!SWIG_IsOK(res2)) {
31055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31056 }
31057 if (!argp2) {
31058 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31059 }
31060 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31061 {
31062 PyThreadState* __tstate = wxPyBeginAllowThreads();
31063 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31068 return resultobj;
31069 fail:
31070 return NULL;
31071 }
31072
31073
31074 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31075 PyObject *resultobj = 0;
31076 wxDataObject *arg1 = (wxDataObject *) 0 ;
31077 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
31078 PyObject *result = 0 ;
31079 void *argp1 = 0 ;
31080 int res1 = 0 ;
31081 int val2 ;
31082 int ecode2 = 0 ;
31083 PyObject * obj0 = 0 ;
31084 PyObject * obj1 = 0 ;
31085 char * kwnames[] = {
31086 (char *) "self",(char *) "dir", NULL
31087 };
31088
31089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
31090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31091 if (!SWIG_IsOK(res1)) {
31092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
31093 }
31094 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31095 if (obj1) {
31096 ecode2 = SWIG_AsVal_int(obj1, &val2);
31097 if (!SWIG_IsOK(ecode2)) {
31098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
31099 }
31100 arg2 = static_cast< wxDataObject::Direction >(val2);
31101 }
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
31105 wxPyEndAllowThreads(__tstate);
31106 if (PyErr_Occurred()) SWIG_fail;
31107 }
31108 resultobj = result;
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31116 PyObject *resultobj = 0;
31117 wxDataObject *arg1 = (wxDataObject *) 0 ;
31118 wxDataFormat *arg2 = 0 ;
31119 PyObject *result = 0 ;
31120 void *argp1 = 0 ;
31121 int res1 = 0 ;
31122 void *argp2 = 0 ;
31123 int res2 = 0 ;
31124 PyObject * obj0 = 0 ;
31125 PyObject * obj1 = 0 ;
31126 char * kwnames[] = {
31127 (char *) "self",(char *) "format", NULL
31128 };
31129
31130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
31131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31132 if (!SWIG_IsOK(res1)) {
31133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
31134 }
31135 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31136 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31137 if (!SWIG_IsOK(res2)) {
31138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31139 }
31140 if (!argp2) {
31141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31142 }
31143 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31144 {
31145 PyThreadState* __tstate = wxPyBeginAllowThreads();
31146 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
31147 wxPyEndAllowThreads(__tstate);
31148 if (PyErr_Occurred()) SWIG_fail;
31149 }
31150 resultobj = result;
31151 return resultobj;
31152 fail:
31153 return NULL;
31154 }
31155
31156
31157 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31158 PyObject *resultobj = 0;
31159 wxDataObject *arg1 = (wxDataObject *) 0 ;
31160 wxDataFormat *arg2 = 0 ;
31161 PyObject *arg3 = (PyObject *) 0 ;
31162 bool result;
31163 void *argp1 = 0 ;
31164 int res1 = 0 ;
31165 void *argp2 = 0 ;
31166 int res2 = 0 ;
31167 PyObject * obj0 = 0 ;
31168 PyObject * obj1 = 0 ;
31169 PyObject * obj2 = 0 ;
31170 char * kwnames[] = {
31171 (char *) "self",(char *) "format",(char *) "data", NULL
31172 };
31173
31174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
31176 if (!SWIG_IsOK(res1)) {
31177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
31178 }
31179 arg1 = reinterpret_cast< wxDataObject * >(argp1);
31180 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31181 if (!SWIG_IsOK(res2)) {
31182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31183 }
31184 if (!argp2) {
31185 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31186 }
31187 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31188 arg3 = obj2;
31189 {
31190 PyThreadState* __tstate = wxPyBeginAllowThreads();
31191 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
31192 wxPyEndAllowThreads(__tstate);
31193 if (PyErr_Occurred()) SWIG_fail;
31194 }
31195 {
31196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31197 }
31198 return resultobj;
31199 fail:
31200 return NULL;
31201 }
31202
31203
31204 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31205 PyObject *obj;
31206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31207 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
31208 return SWIG_Py_Void();
31209 }
31210
31211 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31212 PyObject *resultobj = 0;
31213 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31214 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31215 wxDataObjectSimple *result = 0 ;
31216 void *argp1 = 0 ;
31217 int res1 = 0 ;
31218 PyObject * obj0 = 0 ;
31219 char * kwnames[] = {
31220 (char *) "format", NULL
31221 };
31222
31223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
31224 if (obj0) {
31225 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31226 if (!SWIG_IsOK(res1)) {
31227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31228 }
31229 if (!argp1) {
31230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31231 }
31232 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31233 }
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
31237 wxPyEndAllowThreads(__tstate);
31238 if (PyErr_Occurred()) SWIG_fail;
31239 }
31240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
31241 return resultobj;
31242 fail:
31243 return NULL;
31244 }
31245
31246
31247 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 PyObject *resultobj = 0;
31249 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31250 wxDataFormat *result = 0 ;
31251 void *argp1 = 0 ;
31252 int res1 = 0 ;
31253 PyObject *swig_obj[1] ;
31254
31255 if (!args) SWIG_fail;
31256 swig_obj[0] = args;
31257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31258 if (!SWIG_IsOK(res1)) {
31259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31260 }
31261 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 {
31265 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31266 result = (wxDataFormat *) &_result_ref;
31267 }
31268 wxPyEndAllowThreads(__tstate);
31269 if (PyErr_Occurred()) SWIG_fail;
31270 }
31271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31279 PyObject *resultobj = 0;
31280 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31281 wxDataFormat *arg2 = 0 ;
31282 void *argp1 = 0 ;
31283 int res1 = 0 ;
31284 void *argp2 = 0 ;
31285 int res2 = 0 ;
31286 PyObject * obj0 = 0 ;
31287 PyObject * obj1 = 0 ;
31288 char * kwnames[] = {
31289 (char *) "self",(char *) "format", NULL
31290 };
31291
31292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31294 if (!SWIG_IsOK(res1)) {
31295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31296 }
31297 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31298 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31299 if (!SWIG_IsOK(res2)) {
31300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31301 }
31302 if (!argp2) {
31303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31304 }
31305 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31306 {
31307 PyThreadState* __tstate = wxPyBeginAllowThreads();
31308 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31309 wxPyEndAllowThreads(__tstate);
31310 if (PyErr_Occurred()) SWIG_fail;
31311 }
31312 resultobj = SWIG_Py_Void();
31313 return resultobj;
31314 fail:
31315 return NULL;
31316 }
31317
31318
31319 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31320 PyObject *resultobj = 0;
31321 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31322 size_t result;
31323 void *argp1 = 0 ;
31324 int res1 = 0 ;
31325 PyObject *swig_obj[1] ;
31326
31327 if (!args) SWIG_fail;
31328 swig_obj[0] = args;
31329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31330 if (!SWIG_IsOK(res1)) {
31331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31332 }
31333 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31337 wxPyEndAllowThreads(__tstate);
31338 if (PyErr_Occurred()) SWIG_fail;
31339 }
31340 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31341 return resultobj;
31342 fail:
31343 return NULL;
31344 }
31345
31346
31347 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31348 PyObject *resultobj = 0;
31349 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31350 PyObject *result = 0 ;
31351 void *argp1 = 0 ;
31352 int res1 = 0 ;
31353 PyObject *swig_obj[1] ;
31354
31355 if (!args) SWIG_fail;
31356 swig_obj[0] = args;
31357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31358 if (!SWIG_IsOK(res1)) {
31359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31360 }
31361 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 resultobj = result;
31369 return resultobj;
31370 fail:
31371 return NULL;
31372 }
31373
31374
31375 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31376 PyObject *resultobj = 0;
31377 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31378 PyObject *arg2 = (PyObject *) 0 ;
31379 bool result;
31380 void *argp1 = 0 ;
31381 int res1 = 0 ;
31382 PyObject * obj0 = 0 ;
31383 PyObject * obj1 = 0 ;
31384 char * kwnames[] = {
31385 (char *) "self",(char *) "data", NULL
31386 };
31387
31388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31390 if (!SWIG_IsOK(res1)) {
31391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31392 }
31393 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31394 arg2 = obj1;
31395 {
31396 PyThreadState* __tstate = wxPyBeginAllowThreads();
31397 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31398 wxPyEndAllowThreads(__tstate);
31399 if (PyErr_Occurred()) SWIG_fail;
31400 }
31401 {
31402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31403 }
31404 return resultobj;
31405 fail:
31406 return NULL;
31407 }
31408
31409
31410 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31411 PyObject *obj;
31412 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31413 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31414 return SWIG_Py_Void();
31415 }
31416
31417 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31418 return SWIG_Python_InitShadowInstance(args);
31419 }
31420
31421 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31422 PyObject *resultobj = 0;
31423 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31424 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31425 wxPyDataObjectSimple *result = 0 ;
31426 void *argp1 = 0 ;
31427 int res1 = 0 ;
31428 PyObject * obj0 = 0 ;
31429 char * kwnames[] = {
31430 (char *) "format", NULL
31431 };
31432
31433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31434 if (obj0) {
31435 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31436 if (!SWIG_IsOK(res1)) {
31437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31438 }
31439 if (!argp1) {
31440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31441 }
31442 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31443 }
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31447 wxPyEndAllowThreads(__tstate);
31448 if (PyErr_Occurred()) SWIG_fail;
31449 }
31450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31458 PyObject *resultobj = 0;
31459 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31460 PyObject *arg2 = (PyObject *) 0 ;
31461 PyObject *arg3 = (PyObject *) 0 ;
31462 void *argp1 = 0 ;
31463 int res1 = 0 ;
31464 PyObject * obj0 = 0 ;
31465 PyObject * obj1 = 0 ;
31466 PyObject * obj2 = 0 ;
31467 char * kwnames[] = {
31468 (char *) "self",(char *) "self",(char *) "_class", NULL
31469 };
31470
31471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31473 if (!SWIG_IsOK(res1)) {
31474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31475 }
31476 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31477 arg2 = obj1;
31478 arg3 = obj2;
31479 {
31480 PyThreadState* __tstate = wxPyBeginAllowThreads();
31481 (arg1)->_setCallbackInfo(arg2,arg3);
31482 wxPyEndAllowThreads(__tstate);
31483 if (PyErr_Occurred()) SWIG_fail;
31484 }
31485 resultobj = SWIG_Py_Void();
31486 return resultobj;
31487 fail:
31488 return NULL;
31489 }
31490
31491
31492 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31493 PyObject *obj;
31494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31495 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31496 return SWIG_Py_Void();
31497 }
31498
31499 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31500 return SWIG_Python_InitShadowInstance(args);
31501 }
31502
31503 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31504 PyObject *resultobj = 0;
31505 wxDataObjectComposite *result = 0 ;
31506
31507 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31508 {
31509 PyThreadState* __tstate = wxPyBeginAllowThreads();
31510 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31511 wxPyEndAllowThreads(__tstate);
31512 if (PyErr_Occurred()) SWIG_fail;
31513 }
31514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31522 PyObject *resultobj = 0;
31523 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31524 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31525 bool arg3 = (bool) false ;
31526 void *argp1 = 0 ;
31527 int res1 = 0 ;
31528 int res2 = 0 ;
31529 bool val3 ;
31530 int ecode3 = 0 ;
31531 PyObject * obj0 = 0 ;
31532 PyObject * obj1 = 0 ;
31533 PyObject * obj2 = 0 ;
31534 char * kwnames[] = {
31535 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31536 };
31537
31538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31540 if (!SWIG_IsOK(res1)) {
31541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31542 }
31543 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31544 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31545 if (!SWIG_IsOK(res2)) {
31546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31547 }
31548 if (obj2) {
31549 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31550 if (!SWIG_IsOK(ecode3)) {
31551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31552 }
31553 arg3 = static_cast< bool >(val3);
31554 }
31555 {
31556 PyThreadState* __tstate = wxPyBeginAllowThreads();
31557 (arg1)->Add(arg2,arg3);
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 resultobj = SWIG_Py_Void();
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 SWIGINTERN PyObject *_wrap_DataObjectComposite_GetReceivedFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31569 PyObject *resultobj = 0;
31570 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31571 SwigValueWrapper<wxDataFormat > result;
31572 void *argp1 = 0 ;
31573 int res1 = 0 ;
31574 PyObject *swig_obj[1] ;
31575
31576 if (!args) SWIG_fail;
31577 swig_obj[0] = args;
31578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31579 if (!SWIG_IsOK(res1)) {
31580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_GetReceivedFormat" "', expected argument " "1"" of type '" "wxDataObjectComposite const *""'");
31581 }
31582 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31583 {
31584 PyThreadState* __tstate = wxPyBeginAllowThreads();
31585 result = ((wxDataObjectComposite const *)arg1)->GetReceivedFormat();
31586 wxPyEndAllowThreads(__tstate);
31587 if (PyErr_Occurred()) SWIG_fail;
31588 }
31589 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
31590 return resultobj;
31591 fail:
31592 return NULL;
31593 }
31594
31595
31596 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31597 PyObject *obj;
31598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31599 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31600 return SWIG_Py_Void();
31601 }
31602
31603 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31604 return SWIG_Python_InitShadowInstance(args);
31605 }
31606
31607 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31608 PyObject *resultobj = 0;
31609 wxString const &arg1_defvalue = wxPyEmptyString ;
31610 wxString *arg1 = (wxString *) &arg1_defvalue ;
31611 wxTextDataObject *result = 0 ;
31612 bool temp1 = false ;
31613 PyObject * obj0 = 0 ;
31614 char * kwnames[] = {
31615 (char *) "text", NULL
31616 };
31617
31618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31619 if (obj0) {
31620 {
31621 arg1 = wxString_in_helper(obj0);
31622 if (arg1 == NULL) SWIG_fail;
31623 temp1 = true;
31624 }
31625 }
31626 {
31627 PyThreadState* __tstate = wxPyBeginAllowThreads();
31628 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31629 wxPyEndAllowThreads(__tstate);
31630 if (PyErr_Occurred()) SWIG_fail;
31631 }
31632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31633 {
31634 if (temp1)
31635 delete arg1;
31636 }
31637 return resultobj;
31638 fail:
31639 {
31640 if (temp1)
31641 delete arg1;
31642 }
31643 return NULL;
31644 }
31645
31646
31647 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31648 PyObject *resultobj = 0;
31649 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31650 size_t result;
31651 void *argp1 = 0 ;
31652 int res1 = 0 ;
31653 PyObject *swig_obj[1] ;
31654
31655 if (!args) SWIG_fail;
31656 swig_obj[0] = args;
31657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31658 if (!SWIG_IsOK(res1)) {
31659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31660 }
31661 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 result = (size_t)(arg1)->GetTextLength();
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31676 PyObject *resultobj = 0;
31677 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31678 wxString result;
31679 void *argp1 = 0 ;
31680 int res1 = 0 ;
31681 PyObject *swig_obj[1] ;
31682
31683 if (!args) SWIG_fail;
31684 swig_obj[0] = args;
31685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31686 if (!SWIG_IsOK(res1)) {
31687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31688 }
31689 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31690 {
31691 PyThreadState* __tstate = wxPyBeginAllowThreads();
31692 result = (arg1)->GetText();
31693 wxPyEndAllowThreads(__tstate);
31694 if (PyErr_Occurred()) SWIG_fail;
31695 }
31696 {
31697 #if wxUSE_UNICODE
31698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31699 #else
31700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31701 #endif
31702 }
31703 return resultobj;
31704 fail:
31705 return NULL;
31706 }
31707
31708
31709 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31710 PyObject *resultobj = 0;
31711 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31712 wxString *arg2 = 0 ;
31713 void *argp1 = 0 ;
31714 int res1 = 0 ;
31715 bool temp2 = false ;
31716 PyObject * obj0 = 0 ;
31717 PyObject * obj1 = 0 ;
31718 char * kwnames[] = {
31719 (char *) "self",(char *) "text", NULL
31720 };
31721
31722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31724 if (!SWIG_IsOK(res1)) {
31725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31726 }
31727 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31728 {
31729 arg2 = wxString_in_helper(obj1);
31730 if (arg2 == NULL) SWIG_fail;
31731 temp2 = true;
31732 }
31733 {
31734 PyThreadState* __tstate = wxPyBeginAllowThreads();
31735 (arg1)->SetText((wxString const &)*arg2);
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 resultobj = SWIG_Py_Void();
31740 {
31741 if (temp2)
31742 delete arg2;
31743 }
31744 return resultobj;
31745 fail:
31746 {
31747 if (temp2)
31748 delete arg2;
31749 }
31750 return NULL;
31751 }
31752
31753
31754 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31755 PyObject *obj;
31756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31757 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31758 return SWIG_Py_Void();
31759 }
31760
31761 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 return SWIG_Python_InitShadowInstance(args);
31763 }
31764
31765 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31766 PyObject *resultobj = 0;
31767 wxString const &arg1_defvalue = wxPyEmptyString ;
31768 wxString *arg1 = (wxString *) &arg1_defvalue ;
31769 wxPyTextDataObject *result = 0 ;
31770 bool temp1 = false ;
31771 PyObject * obj0 = 0 ;
31772 char * kwnames[] = {
31773 (char *) "text", NULL
31774 };
31775
31776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31777 if (obj0) {
31778 {
31779 arg1 = wxString_in_helper(obj0);
31780 if (arg1 == NULL) SWIG_fail;
31781 temp1 = true;
31782 }
31783 }
31784 {
31785 PyThreadState* __tstate = wxPyBeginAllowThreads();
31786 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31787 wxPyEndAllowThreads(__tstate);
31788 if (PyErr_Occurred()) SWIG_fail;
31789 }
31790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31791 {
31792 if (temp1)
31793 delete arg1;
31794 }
31795 return resultobj;
31796 fail:
31797 {
31798 if (temp1)
31799 delete arg1;
31800 }
31801 return NULL;
31802 }
31803
31804
31805 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31806 PyObject *resultobj = 0;
31807 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31808 PyObject *arg2 = (PyObject *) 0 ;
31809 PyObject *arg3 = (PyObject *) 0 ;
31810 void *argp1 = 0 ;
31811 int res1 = 0 ;
31812 PyObject * obj0 = 0 ;
31813 PyObject * obj1 = 0 ;
31814 PyObject * obj2 = 0 ;
31815 char * kwnames[] = {
31816 (char *) "self",(char *) "self",(char *) "_class", NULL
31817 };
31818
31819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31821 if (!SWIG_IsOK(res1)) {
31822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31823 }
31824 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31825 arg2 = obj1;
31826 arg3 = obj2;
31827 {
31828 PyThreadState* __tstate = wxPyBeginAllowThreads();
31829 (arg1)->_setCallbackInfo(arg2,arg3);
31830 wxPyEndAllowThreads(__tstate);
31831 if (PyErr_Occurred()) SWIG_fail;
31832 }
31833 resultobj = SWIG_Py_Void();
31834 return resultobj;
31835 fail:
31836 return NULL;
31837 }
31838
31839
31840 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31841 PyObject *obj;
31842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31843 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31844 return SWIG_Py_Void();
31845 }
31846
31847 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31848 return SWIG_Python_InitShadowInstance(args);
31849 }
31850
31851 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31852 PyObject *resultobj = 0;
31853 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31854 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31855 wxBitmapDataObject *result = 0 ;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 PyObject * obj0 = 0 ;
31859 char * kwnames[] = {
31860 (char *) "bitmap", NULL
31861 };
31862
31863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31864 if (obj0) {
31865 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31866 if (!SWIG_IsOK(res1)) {
31867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31868 }
31869 if (!argp1) {
31870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31871 }
31872 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31873 }
31874 {
31875 PyThreadState* __tstate = wxPyBeginAllowThreads();
31876 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31877 wxPyEndAllowThreads(__tstate);
31878 if (PyErr_Occurred()) SWIG_fail;
31879 }
31880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31881 return resultobj;
31882 fail:
31883 return NULL;
31884 }
31885
31886
31887 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31888 PyObject *resultobj = 0;
31889 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31890 wxBitmap result;
31891 void *argp1 = 0 ;
31892 int res1 = 0 ;
31893 PyObject *swig_obj[1] ;
31894
31895 if (!args) SWIG_fail;
31896 swig_obj[0] = args;
31897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31898 if (!SWIG_IsOK(res1)) {
31899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31900 }
31901 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31902 {
31903 PyThreadState* __tstate = wxPyBeginAllowThreads();
31904 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31905 wxPyEndAllowThreads(__tstate);
31906 if (PyErr_Occurred()) SWIG_fail;
31907 }
31908 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31909 return resultobj;
31910 fail:
31911 return NULL;
31912 }
31913
31914
31915 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31916 PyObject *resultobj = 0;
31917 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31918 wxBitmap *arg2 = 0 ;
31919 void *argp1 = 0 ;
31920 int res1 = 0 ;
31921 void *argp2 = 0 ;
31922 int res2 = 0 ;
31923 PyObject * obj0 = 0 ;
31924 PyObject * obj1 = 0 ;
31925 char * kwnames[] = {
31926 (char *) "self",(char *) "bitmap", NULL
31927 };
31928
31929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31931 if (!SWIG_IsOK(res1)) {
31932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31933 }
31934 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31935 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31936 if (!SWIG_IsOK(res2)) {
31937 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31938 }
31939 if (!argp2) {
31940 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31941 }
31942 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31943 {
31944 PyThreadState* __tstate = wxPyBeginAllowThreads();
31945 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31946 wxPyEndAllowThreads(__tstate);
31947 if (PyErr_Occurred()) SWIG_fail;
31948 }
31949 resultobj = SWIG_Py_Void();
31950 return resultobj;
31951 fail:
31952 return NULL;
31953 }
31954
31955
31956 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31957 PyObject *obj;
31958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31959 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31960 return SWIG_Py_Void();
31961 }
31962
31963 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31964 return SWIG_Python_InitShadowInstance(args);
31965 }
31966
31967 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31968 PyObject *resultobj = 0;
31969 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31970 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31971 wxPyBitmapDataObject *result = 0 ;
31972 void *argp1 = 0 ;
31973 int res1 = 0 ;
31974 PyObject * obj0 = 0 ;
31975 char * kwnames[] = {
31976 (char *) "bitmap", NULL
31977 };
31978
31979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31980 if (obj0) {
31981 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31982 if (!SWIG_IsOK(res1)) {
31983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31984 }
31985 if (!argp1) {
31986 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31987 }
31988 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31989 }
31990 {
31991 PyThreadState* __tstate = wxPyBeginAllowThreads();
31992 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31993 wxPyEndAllowThreads(__tstate);
31994 if (PyErr_Occurred()) SWIG_fail;
31995 }
31996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31997 return resultobj;
31998 fail:
31999 return NULL;
32000 }
32001
32002
32003 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32004 PyObject *resultobj = 0;
32005 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
32006 PyObject *arg2 = (PyObject *) 0 ;
32007 PyObject *arg3 = (PyObject *) 0 ;
32008 void *argp1 = 0 ;
32009 int res1 = 0 ;
32010 PyObject * obj0 = 0 ;
32011 PyObject * obj1 = 0 ;
32012 PyObject * obj2 = 0 ;
32013 char * kwnames[] = {
32014 (char *) "self",(char *) "self",(char *) "_class", NULL
32015 };
32016
32017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
32019 if (!SWIG_IsOK(res1)) {
32020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
32021 }
32022 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
32023 arg2 = obj1;
32024 arg3 = obj2;
32025 {
32026 PyThreadState* __tstate = wxPyBeginAllowThreads();
32027 (arg1)->_setCallbackInfo(arg2,arg3);
32028 wxPyEndAllowThreads(__tstate);
32029 if (PyErr_Occurred()) SWIG_fail;
32030 }
32031 resultobj = SWIG_Py_Void();
32032 return resultobj;
32033 fail:
32034 return NULL;
32035 }
32036
32037
32038 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32039 PyObject *obj;
32040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32041 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
32042 return SWIG_Py_Void();
32043 }
32044
32045 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32046 return SWIG_Python_InitShadowInstance(args);
32047 }
32048
32049 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32050 PyObject *resultobj = 0;
32051 wxFileDataObject *result = 0 ;
32052
32053 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
32054 {
32055 PyThreadState* __tstate = wxPyBeginAllowThreads();
32056 result = (wxFileDataObject *)new wxFileDataObject();
32057 wxPyEndAllowThreads(__tstate);
32058 if (PyErr_Occurred()) SWIG_fail;
32059 }
32060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
32061 return resultobj;
32062 fail:
32063 return NULL;
32064 }
32065
32066
32067 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32068 PyObject *resultobj = 0;
32069 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32070 wxArrayString *result = 0 ;
32071 void *argp1 = 0 ;
32072 int res1 = 0 ;
32073 PyObject *swig_obj[1] ;
32074
32075 if (!args) SWIG_fail;
32076 swig_obj[0] = args;
32077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32078 if (!SWIG_IsOK(res1)) {
32079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32080 }
32081 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32082 {
32083 PyThreadState* __tstate = wxPyBeginAllowThreads();
32084 {
32085 wxArrayString const &_result_ref = (arg1)->GetFilenames();
32086 result = (wxArrayString *) &_result_ref;
32087 }
32088 wxPyEndAllowThreads(__tstate);
32089 if (PyErr_Occurred()) SWIG_fail;
32090 }
32091 {
32092 resultobj = wxArrayString2PyList_helper(*result);
32093 }
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj = 0;
32102 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
32103 wxString *arg2 = 0 ;
32104 void *argp1 = 0 ;
32105 int res1 = 0 ;
32106 bool temp2 = false ;
32107 PyObject * obj0 = 0 ;
32108 PyObject * obj1 = 0 ;
32109 char * kwnames[] = {
32110 (char *) "self",(char *) "filename", NULL
32111 };
32112
32113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
32114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
32115 if (!SWIG_IsOK(res1)) {
32116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
32117 }
32118 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
32119 {
32120 arg2 = wxString_in_helper(obj1);
32121 if (arg2 == NULL) SWIG_fail;
32122 temp2 = true;
32123 }
32124 {
32125 PyThreadState* __tstate = wxPyBeginAllowThreads();
32126 (arg1)->AddFile((wxString const &)*arg2);
32127 wxPyEndAllowThreads(__tstate);
32128 if (PyErr_Occurred()) SWIG_fail;
32129 }
32130 resultobj = SWIG_Py_Void();
32131 {
32132 if (temp2)
32133 delete arg2;
32134 }
32135 return resultobj;
32136 fail:
32137 {
32138 if (temp2)
32139 delete arg2;
32140 }
32141 return NULL;
32142 }
32143
32144
32145 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32146 PyObject *obj;
32147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32148 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
32149 return SWIG_Py_Void();
32150 }
32151
32152 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32153 return SWIG_Python_InitShadowInstance(args);
32154 }
32155
32156 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32157 PyObject *resultobj = 0;
32158 wxDataFormat *arg1 = 0 ;
32159 wxCustomDataObject *result = 0 ;
32160 void *argp1 = 0 ;
32161 int res1 = 0 ;
32162
32163 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
32165 if (!SWIG_IsOK(res1)) {
32166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32167 }
32168 if (!argp1) {
32169 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
32170 }
32171 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
32172 {
32173 PyThreadState* __tstate = wxPyBeginAllowThreads();
32174 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
32175 wxPyEndAllowThreads(__tstate);
32176 if (PyErr_Occurred()) SWIG_fail;
32177 }
32178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32179 return resultobj;
32180 fail:
32181 return NULL;
32182 }
32183
32184
32185 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
32186 PyObject *resultobj = 0;
32187 wxString *arg1 = 0 ;
32188 wxCustomDataObject *result = 0 ;
32189 bool temp1 = false ;
32190
32191 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
32192 {
32193 arg1 = wxString_in_helper(swig_obj[0]);
32194 if (arg1 == NULL) SWIG_fail;
32195 temp1 = true;
32196 }
32197 {
32198 PyThreadState* __tstate = wxPyBeginAllowThreads();
32199 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
32200 wxPyEndAllowThreads(__tstate);
32201 if (PyErr_Occurred()) SWIG_fail;
32202 }
32203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32204 {
32205 if (temp1)
32206 delete arg1;
32207 }
32208 return resultobj;
32209 fail:
32210 {
32211 if (temp1)
32212 delete arg1;
32213 }
32214 return NULL;
32215 }
32216
32217
32218 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
32219 PyObject *resultobj = 0;
32220 wxCustomDataObject *result = 0 ;
32221
32222 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
32223 {
32224 PyThreadState* __tstate = wxPyBeginAllowThreads();
32225 result = (wxCustomDataObject *)new wxCustomDataObject();
32226 wxPyEndAllowThreads(__tstate);
32227 if (PyErr_Occurred()) SWIG_fail;
32228 }
32229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
32230 return resultobj;
32231 fail:
32232 return NULL;
32233 }
32234
32235
32236 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
32237 int argc;
32238 PyObject *argv[2];
32239
32240 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
32241 --argc;
32242 if (argc == 0) {
32243 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
32244 }
32245 if (argc == 1) {
32246 int _v = 0;
32247 {
32248 {
32249 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
32250 }
32251 }
32252 if (!_v) goto check_2;
32253 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
32254 }
32255 check_2:
32256
32257 if (argc == 1) {
32258 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
32259 }
32260
32261 fail:
32262 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
32263 return NULL;
32264 }
32265
32266
32267 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32268 PyObject *resultobj = 0;
32269 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32270 PyObject *arg2 = (PyObject *) 0 ;
32271 bool result;
32272 void *argp1 = 0 ;
32273 int res1 = 0 ;
32274 PyObject * obj0 = 0 ;
32275 PyObject * obj1 = 0 ;
32276 char * kwnames[] = {
32277 (char *) "self",(char *) "data", NULL
32278 };
32279
32280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32282 if (!SWIG_IsOK(res1)) {
32283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32284 }
32285 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32286 arg2 = obj1;
32287 {
32288 PyThreadState* __tstate = wxPyBeginAllowThreads();
32289 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32290 wxPyEndAllowThreads(__tstate);
32291 if (PyErr_Occurred()) SWIG_fail;
32292 }
32293 {
32294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32295 }
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32303 PyObject *resultobj = 0;
32304 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32305 size_t result;
32306 void *argp1 = 0 ;
32307 int res1 = 0 ;
32308 PyObject *swig_obj[1] ;
32309
32310 if (!args) SWIG_fail;
32311 swig_obj[0] = args;
32312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32313 if (!SWIG_IsOK(res1)) {
32314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32315 }
32316 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 result = (size_t)(arg1)->GetSize();
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32331 PyObject *resultobj = 0;
32332 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32333 PyObject *result = 0 ;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 PyObject *swig_obj[1] ;
32337
32338 if (!args) SWIG_fail;
32339 swig_obj[0] = args;
32340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32341 if (!SWIG_IsOK(res1)) {
32342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32343 }
32344 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32345 {
32346 PyThreadState* __tstate = wxPyBeginAllowThreads();
32347 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32348 wxPyEndAllowThreads(__tstate);
32349 if (PyErr_Occurred()) SWIG_fail;
32350 }
32351 resultobj = result;
32352 return resultobj;
32353 fail:
32354 return NULL;
32355 }
32356
32357
32358 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32359 PyObject *obj;
32360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32361 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32362 return SWIG_Py_Void();
32363 }
32364
32365 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32366 return SWIG_Python_InitShadowInstance(args);
32367 }
32368
32369 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32370 PyObject *resultobj = 0;
32371 wxURLDataObject *result = 0 ;
32372
32373 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32374 {
32375 PyThreadState* __tstate = wxPyBeginAllowThreads();
32376 result = (wxURLDataObject *)new wxURLDataObject();
32377 wxPyEndAllowThreads(__tstate);
32378 if (PyErr_Occurred()) SWIG_fail;
32379 }
32380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32381 return resultobj;
32382 fail:
32383 return NULL;
32384 }
32385
32386
32387 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32388 PyObject *resultobj = 0;
32389 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32390 wxString result;
32391 void *argp1 = 0 ;
32392 int res1 = 0 ;
32393 PyObject *swig_obj[1] ;
32394
32395 if (!args) SWIG_fail;
32396 swig_obj[0] = args;
32397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32398 if (!SWIG_IsOK(res1)) {
32399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32400 }
32401 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32402 {
32403 PyThreadState* __tstate = wxPyBeginAllowThreads();
32404 result = (arg1)->GetURL();
32405 wxPyEndAllowThreads(__tstate);
32406 if (PyErr_Occurred()) SWIG_fail;
32407 }
32408 {
32409 #if wxUSE_UNICODE
32410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32411 #else
32412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32413 #endif
32414 }
32415 return resultobj;
32416 fail:
32417 return NULL;
32418 }
32419
32420
32421 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32422 PyObject *resultobj = 0;
32423 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32424 wxString *arg2 = 0 ;
32425 void *argp1 = 0 ;
32426 int res1 = 0 ;
32427 bool temp2 = false ;
32428 PyObject * obj0 = 0 ;
32429 PyObject * obj1 = 0 ;
32430 char * kwnames[] = {
32431 (char *) "self",(char *) "url", NULL
32432 };
32433
32434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32436 if (!SWIG_IsOK(res1)) {
32437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32438 }
32439 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32440 {
32441 arg2 = wxString_in_helper(obj1);
32442 if (arg2 == NULL) SWIG_fail;
32443 temp2 = true;
32444 }
32445 {
32446 PyThreadState* __tstate = wxPyBeginAllowThreads();
32447 (arg1)->SetURL((wxString const &)*arg2);
32448 wxPyEndAllowThreads(__tstate);
32449 if (PyErr_Occurred()) SWIG_fail;
32450 }
32451 resultobj = SWIG_Py_Void();
32452 {
32453 if (temp2)
32454 delete arg2;
32455 }
32456 return resultobj;
32457 fail:
32458 {
32459 if (temp2)
32460 delete arg2;
32461 }
32462 return NULL;
32463 }
32464
32465
32466 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32467 PyObject *obj;
32468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32469 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32470 return SWIG_Py_Void();
32471 }
32472
32473 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32474 return SWIG_Python_InitShadowInstance(args);
32475 }
32476
32477 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32478 PyObject *resultobj = 0;
32479 wxMetafileDataObject *result = 0 ;
32480
32481 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32482 {
32483 PyThreadState* __tstate = wxPyBeginAllowThreads();
32484 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32489 return resultobj;
32490 fail:
32491 return NULL;
32492 }
32493
32494
32495 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32496 PyObject *obj;
32497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32498 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32499 return SWIG_Py_Void();
32500 }
32501
32502 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32503 return SWIG_Python_InitShadowInstance(args);
32504 }
32505
32506 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32507 PyObject *resultobj = 0;
32508 wxDragResult arg1 ;
32509 bool result;
32510 int val1 ;
32511 int ecode1 = 0 ;
32512 PyObject * obj0 = 0 ;
32513 char * kwnames[] = {
32514 (char *) "res", NULL
32515 };
32516
32517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32518 ecode1 = SWIG_AsVal_int(obj0, &val1);
32519 if (!SWIG_IsOK(ecode1)) {
32520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32521 }
32522 arg1 = static_cast< wxDragResult >(val1);
32523 {
32524 PyThreadState* __tstate = wxPyBeginAllowThreads();
32525 result = (bool)wxIsDragResultOk(arg1);
32526 wxPyEndAllowThreads(__tstate);
32527 if (PyErr_Occurred()) SWIG_fail;
32528 }
32529 {
32530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32531 }
32532 return resultobj;
32533 fail:
32534 return NULL;
32535 }
32536
32537
32538 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32539 PyObject *resultobj = 0;
32540 wxWindow *arg1 = (wxWindow *) 0 ;
32541 wxIcon const &arg2_defvalue = wxNullIcon ;
32542 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
32543 wxIcon const &arg3_defvalue = wxNullIcon ;
32544 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
32545 wxIcon const &arg4_defvalue = wxNullIcon ;
32546 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
32547 wxPyDropSource *result = 0 ;
32548 void *argp1 = 0 ;
32549 int res1 = 0 ;
32550 void *argp2 = 0 ;
32551 int res2 = 0 ;
32552 void *argp3 = 0 ;
32553 int res3 = 0 ;
32554 void *argp4 = 0 ;
32555 int res4 = 0 ;
32556 PyObject * obj0 = 0 ;
32557 PyObject * obj1 = 0 ;
32558 PyObject * obj2 = 0 ;
32559 PyObject * obj3 = 0 ;
32560 char * kwnames[] = {
32561 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32562 };
32563
32564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32566 if (!SWIG_IsOK(res1)) {
32567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32568 }
32569 arg1 = reinterpret_cast< wxWindow * >(argp1);
32570 if (obj1) {
32571 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxIcon, 0 | 0);
32572 if (!SWIG_IsOK(res2)) {
32573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32574 }
32575 if (!argp2) {
32576 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxIcon const &""'");
32577 }
32578 arg2 = reinterpret_cast< wxIcon * >(argp2);
32579 }
32580 if (obj2) {
32581 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIcon, 0 | 0);
32582 if (!SWIG_IsOK(res3)) {
32583 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32584 }
32585 if (!argp3) {
32586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxIcon const &""'");
32587 }
32588 arg3 = reinterpret_cast< wxIcon * >(argp3);
32589 }
32590 if (obj3) {
32591 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxIcon, 0 | 0);
32592 if (!SWIG_IsOK(res4)) {
32593 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32594 }
32595 if (!argp4) {
32596 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxIcon const &""'");
32597 }
32598 arg4 = reinterpret_cast< wxIcon * >(argp4);
32599 }
32600 {
32601 PyThreadState* __tstate = wxPyBeginAllowThreads();
32602 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
32603 wxPyEndAllowThreads(__tstate);
32604 if (PyErr_Occurred()) SWIG_fail;
32605 }
32606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32607 return resultobj;
32608 fail:
32609 return NULL;
32610 }
32611
32612
32613 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32614 PyObject *resultobj = 0;
32615 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32616 PyObject *arg2 = (PyObject *) 0 ;
32617 PyObject *arg3 = (PyObject *) 0 ;
32618 int arg4 ;
32619 void *argp1 = 0 ;
32620 int res1 = 0 ;
32621 int val4 ;
32622 int ecode4 = 0 ;
32623 PyObject * obj0 = 0 ;
32624 PyObject * obj1 = 0 ;
32625 PyObject * obj2 = 0 ;
32626 PyObject * obj3 = 0 ;
32627 char * kwnames[] = {
32628 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32629 };
32630
32631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32633 if (!SWIG_IsOK(res1)) {
32634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32635 }
32636 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32637 arg2 = obj1;
32638 arg3 = obj2;
32639 ecode4 = SWIG_AsVal_int(obj3, &val4);
32640 if (!SWIG_IsOK(ecode4)) {
32641 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32642 }
32643 arg4 = static_cast< int >(val4);
32644 {
32645 PyThreadState* __tstate = wxPyBeginAllowThreads();
32646 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32647 wxPyEndAllowThreads(__tstate);
32648 if (PyErr_Occurred()) SWIG_fail;
32649 }
32650 resultobj = SWIG_Py_Void();
32651 return resultobj;
32652 fail:
32653 return NULL;
32654 }
32655
32656
32657 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32658 PyObject *resultobj = 0;
32659 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32660 void *argp1 = 0 ;
32661 int res1 = 0 ;
32662 PyObject *swig_obj[1] ;
32663
32664 if (!args) SWIG_fail;
32665 swig_obj[0] = args;
32666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32667 if (!SWIG_IsOK(res1)) {
32668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32669 }
32670 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32671 {
32672 PyThreadState* __tstate = wxPyBeginAllowThreads();
32673 delete arg1;
32674
32675 wxPyEndAllowThreads(__tstate);
32676 if (PyErr_Occurred()) SWIG_fail;
32677 }
32678 resultobj = SWIG_Py_Void();
32679 return resultobj;
32680 fail:
32681 return NULL;
32682 }
32683
32684
32685 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32686 PyObject *resultobj = 0;
32687 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32688 wxDataObject *arg2 = 0 ;
32689 void *argp1 = 0 ;
32690 int res1 = 0 ;
32691 void *argp2 = 0 ;
32692 int res2 = 0 ;
32693 PyObject * obj0 = 0 ;
32694 PyObject * obj1 = 0 ;
32695 char * kwnames[] = {
32696 (char *) "self",(char *) "data", NULL
32697 };
32698
32699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32701 if (!SWIG_IsOK(res1)) {
32702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32703 }
32704 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32705 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32706 if (!SWIG_IsOK(res2)) {
32707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32708 }
32709 if (!argp2) {
32710 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32711 }
32712 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32713 {
32714 PyThreadState* __tstate = wxPyBeginAllowThreads();
32715 (arg1)->SetData(*arg2);
32716 wxPyEndAllowThreads(__tstate);
32717 if (PyErr_Occurred()) SWIG_fail;
32718 }
32719 resultobj = SWIG_Py_Void();
32720 return resultobj;
32721 fail:
32722 return NULL;
32723 }
32724
32725
32726 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32727 PyObject *resultobj = 0;
32728 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32729 wxDataObject *result = 0 ;
32730 void *argp1 = 0 ;
32731 int res1 = 0 ;
32732 PyObject *swig_obj[1] ;
32733
32734 if (!args) SWIG_fail;
32735 swig_obj[0] = args;
32736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32737 if (!SWIG_IsOK(res1)) {
32738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32739 }
32740 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32741 {
32742 PyThreadState* __tstate = wxPyBeginAllowThreads();
32743 result = (wxDataObject *)(arg1)->GetDataObject();
32744 wxPyEndAllowThreads(__tstate);
32745 if (PyErr_Occurred()) SWIG_fail;
32746 }
32747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32748 return resultobj;
32749 fail:
32750 return NULL;
32751 }
32752
32753
32754 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32755 PyObject *resultobj = 0;
32756 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32757 wxDragResult arg2 ;
32758 wxCursor *arg3 = 0 ;
32759 void *argp1 = 0 ;
32760 int res1 = 0 ;
32761 int val2 ;
32762 int ecode2 = 0 ;
32763 void *argp3 = 0 ;
32764 int res3 = 0 ;
32765 PyObject * obj0 = 0 ;
32766 PyObject * obj1 = 0 ;
32767 PyObject * obj2 = 0 ;
32768 char * kwnames[] = {
32769 (char *) "self",(char *) "res",(char *) "cursor", NULL
32770 };
32771
32772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32774 if (!SWIG_IsOK(res1)) {
32775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32776 }
32777 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32778 ecode2 = SWIG_AsVal_int(obj1, &val2);
32779 if (!SWIG_IsOK(ecode2)) {
32780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32781 }
32782 arg2 = static_cast< wxDragResult >(val2);
32783 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32784 if (!SWIG_IsOK(res3)) {
32785 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32786 }
32787 if (!argp3) {
32788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32789 }
32790 arg3 = reinterpret_cast< wxCursor * >(argp3);
32791 {
32792 PyThreadState* __tstate = wxPyBeginAllowThreads();
32793 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32794 wxPyEndAllowThreads(__tstate);
32795 if (PyErr_Occurred()) SWIG_fail;
32796 }
32797 resultobj = SWIG_Py_Void();
32798 return resultobj;
32799 fail:
32800 return NULL;
32801 }
32802
32803
32804 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32805 PyObject *resultobj = 0;
32806 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32807 int arg2 = (int) wxDrag_CopyOnly ;
32808 wxDragResult result;
32809 void *argp1 = 0 ;
32810 int res1 = 0 ;
32811 int val2 ;
32812 int ecode2 = 0 ;
32813 PyObject * obj0 = 0 ;
32814 PyObject * obj1 = 0 ;
32815 char * kwnames[] = {
32816 (char *) "self",(char *) "flags", NULL
32817 };
32818
32819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32821 if (!SWIG_IsOK(res1)) {
32822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32823 }
32824 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32825 if (obj1) {
32826 ecode2 = SWIG_AsVal_int(obj1, &val2);
32827 if (!SWIG_IsOK(ecode2)) {
32828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32829 }
32830 arg2 = static_cast< int >(val2);
32831 }
32832 {
32833 PyThreadState* __tstate = wxPyBeginAllowThreads();
32834 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32835 wxPyEndAllowThreads(__tstate);
32836 if (PyErr_Occurred()) SWIG_fail;
32837 }
32838 resultobj = SWIG_From_int(static_cast< int >(result));
32839 return resultobj;
32840 fail:
32841 return NULL;
32842 }
32843
32844
32845 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32846 PyObject *resultobj = 0;
32847 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32848 wxDragResult arg2 ;
32849 bool result;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 int val2 ;
32853 int ecode2 = 0 ;
32854 PyObject * obj0 = 0 ;
32855 PyObject * obj1 = 0 ;
32856 char * kwnames[] = {
32857 (char *) "self",(char *) "effect", NULL
32858 };
32859
32860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32862 if (!SWIG_IsOK(res1)) {
32863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32864 }
32865 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32866 ecode2 = SWIG_AsVal_int(obj1, &val2);
32867 if (!SWIG_IsOK(ecode2)) {
32868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32869 }
32870 arg2 = static_cast< wxDragResult >(val2);
32871 {
32872 PyThreadState* __tstate = wxPyBeginAllowThreads();
32873 result = (bool)(arg1)->GiveFeedback(arg2);
32874 wxPyEndAllowThreads(__tstate);
32875 if (PyErr_Occurred()) SWIG_fail;
32876 }
32877 {
32878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32879 }
32880 return resultobj;
32881 fail:
32882 return NULL;
32883 }
32884
32885
32886 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32887 PyObject *obj;
32888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32889 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32890 return SWIG_Py_Void();
32891 }
32892
32893 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32894 return SWIG_Python_InitShadowInstance(args);
32895 }
32896
32897 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32898 PyObject *resultobj = 0;
32899 wxDataObject *arg1 = (wxDataObject *) NULL ;
32900 wxPyDropTarget *result = 0 ;
32901 int res1 = 0 ;
32902 PyObject * obj0 = 0 ;
32903 char * kwnames[] = {
32904 (char *) "dataObject", NULL
32905 };
32906
32907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32908 if (obj0) {
32909 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32910 if (!SWIG_IsOK(res1)) {
32911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32912 }
32913 }
32914 {
32915 PyThreadState* __tstate = wxPyBeginAllowThreads();
32916 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32917 wxPyEndAllowThreads(__tstate);
32918 if (PyErr_Occurred()) SWIG_fail;
32919 }
32920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32921 return resultobj;
32922 fail:
32923 return NULL;
32924 }
32925
32926
32927 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32928 PyObject *resultobj = 0;
32929 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32930 PyObject *arg2 = (PyObject *) 0 ;
32931 PyObject *arg3 = (PyObject *) 0 ;
32932 void *argp1 = 0 ;
32933 int res1 = 0 ;
32934 PyObject * obj0 = 0 ;
32935 PyObject * obj1 = 0 ;
32936 PyObject * obj2 = 0 ;
32937 char * kwnames[] = {
32938 (char *) "self",(char *) "self",(char *) "_class", NULL
32939 };
32940
32941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32943 if (!SWIG_IsOK(res1)) {
32944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32945 }
32946 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32947 arg2 = obj1;
32948 arg3 = obj2;
32949 {
32950 PyThreadState* __tstate = wxPyBeginAllowThreads();
32951 (arg1)->_setCallbackInfo(arg2,arg3);
32952 wxPyEndAllowThreads(__tstate);
32953 if (PyErr_Occurred()) SWIG_fail;
32954 }
32955 resultobj = SWIG_Py_Void();
32956 return resultobj;
32957 fail:
32958 return NULL;
32959 }
32960
32961
32962 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32963 PyObject *resultobj = 0;
32964 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32965 void *argp1 = 0 ;
32966 int res1 = 0 ;
32967 PyObject *swig_obj[1] ;
32968
32969 if (!args) SWIG_fail;
32970 swig_obj[0] = args;
32971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32972 if (!SWIG_IsOK(res1)) {
32973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32974 }
32975 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 delete arg1;
32979
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 resultobj = SWIG_Py_Void();
32984 return resultobj;
32985 fail:
32986 return NULL;
32987 }
32988
32989
32990 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32991 PyObject *resultobj = 0;
32992 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32993 wxDataObject *result = 0 ;
32994 void *argp1 = 0 ;
32995 int res1 = 0 ;
32996 PyObject *swig_obj[1] ;
32997
32998 if (!args) SWIG_fail;
32999 swig_obj[0] = args;
33000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33001 if (!SWIG_IsOK(res1)) {
33002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33003 }
33004 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33005 {
33006 PyThreadState* __tstate = wxPyBeginAllowThreads();
33007 result = (wxDataObject *)(arg1)->GetDataObject();
33008 wxPyEndAllowThreads(__tstate);
33009 if (PyErr_Occurred()) SWIG_fail;
33010 }
33011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
33012 return resultobj;
33013 fail:
33014 return NULL;
33015 }
33016
33017
33018 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33019 PyObject *resultobj = 0;
33020 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33021 wxDataObject *arg2 = (wxDataObject *) 0 ;
33022 void *argp1 = 0 ;
33023 int res1 = 0 ;
33024 int res2 = 0 ;
33025 PyObject * obj0 = 0 ;
33026 PyObject * obj1 = 0 ;
33027 char * kwnames[] = {
33028 (char *) "self",(char *) "dataObject", NULL
33029 };
33030
33031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
33032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33033 if (!SWIG_IsOK(res1)) {
33034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33035 }
33036 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33037 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
33038 if (!SWIG_IsOK(res2)) {
33039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
33040 }
33041 {
33042 PyThreadState* __tstate = wxPyBeginAllowThreads();
33043 (arg1)->SetDataObject(arg2);
33044 wxPyEndAllowThreads(__tstate);
33045 if (PyErr_Occurred()) SWIG_fail;
33046 }
33047 resultobj = SWIG_Py_Void();
33048 return resultobj;
33049 fail:
33050 return NULL;
33051 }
33052
33053
33054 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33055 PyObject *resultobj = 0;
33056 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33057 int arg2 ;
33058 int arg3 ;
33059 wxDragResult arg4 ;
33060 wxDragResult result;
33061 void *argp1 = 0 ;
33062 int res1 = 0 ;
33063 int val2 ;
33064 int ecode2 = 0 ;
33065 int val3 ;
33066 int ecode3 = 0 ;
33067 int val4 ;
33068 int ecode4 = 0 ;
33069 PyObject * obj0 = 0 ;
33070 PyObject * obj1 = 0 ;
33071 PyObject * obj2 = 0 ;
33072 PyObject * obj3 = 0 ;
33073 char * kwnames[] = {
33074 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33075 };
33076
33077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33081 }
33082 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33083 ecode2 = SWIG_AsVal_int(obj1, &val2);
33084 if (!SWIG_IsOK(ecode2)) {
33085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33086 }
33087 arg2 = static_cast< int >(val2);
33088 ecode3 = SWIG_AsVal_int(obj2, &val3);
33089 if (!SWIG_IsOK(ecode3)) {
33090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33091 }
33092 arg3 = static_cast< int >(val3);
33093 ecode4 = SWIG_AsVal_int(obj3, &val4);
33094 if (!SWIG_IsOK(ecode4)) {
33095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33096 }
33097 arg4 = static_cast< wxDragResult >(val4);
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 resultobj = SWIG_From_int(static_cast< int >(result));
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33112 PyObject *resultobj = 0;
33113 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33114 int arg2 ;
33115 int arg3 ;
33116 wxDragResult arg4 ;
33117 wxDragResult result;
33118 void *argp1 = 0 ;
33119 int res1 = 0 ;
33120 int val2 ;
33121 int ecode2 = 0 ;
33122 int val3 ;
33123 int ecode3 = 0 ;
33124 int val4 ;
33125 int ecode4 = 0 ;
33126 PyObject * obj0 = 0 ;
33127 PyObject * obj1 = 0 ;
33128 PyObject * obj2 = 0 ;
33129 PyObject * obj3 = 0 ;
33130 char * kwnames[] = {
33131 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33132 };
33133
33134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33136 if (!SWIG_IsOK(res1)) {
33137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33138 }
33139 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33140 ecode2 = SWIG_AsVal_int(obj1, &val2);
33141 if (!SWIG_IsOK(ecode2)) {
33142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33143 }
33144 arg2 = static_cast< int >(val2);
33145 ecode3 = SWIG_AsVal_int(obj2, &val3);
33146 if (!SWIG_IsOK(ecode3)) {
33147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33148 }
33149 arg3 = static_cast< int >(val3);
33150 ecode4 = SWIG_AsVal_int(obj3, &val4);
33151 if (!SWIG_IsOK(ecode4)) {
33152 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33153 }
33154 arg4 = static_cast< wxDragResult >(val4);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 resultobj = SWIG_From_int(static_cast< int >(result));
33162 return resultobj;
33163 fail:
33164 return NULL;
33165 }
33166
33167
33168 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33169 PyObject *resultobj = 0;
33170 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33171 void *argp1 = 0 ;
33172 int res1 = 0 ;
33173 PyObject *swig_obj[1] ;
33174
33175 if (!args) SWIG_fail;
33176 swig_obj[0] = args;
33177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33178 if (!SWIG_IsOK(res1)) {
33179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33180 }
33181 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33182 {
33183 PyThreadState* __tstate = wxPyBeginAllowThreads();
33184 (arg1)->OnLeave();
33185 wxPyEndAllowThreads(__tstate);
33186 if (PyErr_Occurred()) SWIG_fail;
33187 }
33188 resultobj = SWIG_Py_Void();
33189 return resultobj;
33190 fail:
33191 return NULL;
33192 }
33193
33194
33195 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33196 PyObject *resultobj = 0;
33197 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33198 int arg2 ;
33199 int arg3 ;
33200 bool result;
33201 void *argp1 = 0 ;
33202 int res1 = 0 ;
33203 int val2 ;
33204 int ecode2 = 0 ;
33205 int val3 ;
33206 int ecode3 = 0 ;
33207 PyObject * obj0 = 0 ;
33208 PyObject * obj1 = 0 ;
33209 PyObject * obj2 = 0 ;
33210 char * kwnames[] = {
33211 (char *) "self",(char *) "x",(char *) "y", NULL
33212 };
33213
33214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33216 if (!SWIG_IsOK(res1)) {
33217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33218 }
33219 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33220 ecode2 = SWIG_AsVal_int(obj1, &val2);
33221 if (!SWIG_IsOK(ecode2)) {
33222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33223 }
33224 arg2 = static_cast< int >(val2);
33225 ecode3 = SWIG_AsVal_int(obj2, &val3);
33226 if (!SWIG_IsOK(ecode3)) {
33227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33228 }
33229 arg3 = static_cast< int >(val3);
33230 {
33231 PyThreadState* __tstate = wxPyBeginAllowThreads();
33232 result = (bool)(arg1)->OnDrop(arg2,arg3);
33233 wxPyEndAllowThreads(__tstate);
33234 if (PyErr_Occurred()) SWIG_fail;
33235 }
33236 {
33237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33238 }
33239 return resultobj;
33240 fail:
33241 return NULL;
33242 }
33243
33244
33245 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33246 PyObject *resultobj = 0;
33247 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33248 bool result;
33249 void *argp1 = 0 ;
33250 int res1 = 0 ;
33251 PyObject *swig_obj[1] ;
33252
33253 if (!args) SWIG_fail;
33254 swig_obj[0] = args;
33255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33256 if (!SWIG_IsOK(res1)) {
33257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33258 }
33259 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33260 {
33261 PyThreadState* __tstate = wxPyBeginAllowThreads();
33262 result = (bool)(arg1)->GetData();
33263 wxPyEndAllowThreads(__tstate);
33264 if (PyErr_Occurred()) SWIG_fail;
33265 }
33266 {
33267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33268 }
33269 return resultobj;
33270 fail:
33271 return NULL;
33272 }
33273
33274
33275 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33276 PyObject *resultobj = 0;
33277 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33278 wxDragResult arg2 ;
33279 void *argp1 = 0 ;
33280 int res1 = 0 ;
33281 int val2 ;
33282 int ecode2 = 0 ;
33283 PyObject * obj0 = 0 ;
33284 PyObject * obj1 = 0 ;
33285 char * kwnames[] = {
33286 (char *) "self",(char *) "action", NULL
33287 };
33288
33289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33291 if (!SWIG_IsOK(res1)) {
33292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33293 }
33294 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33295 ecode2 = SWIG_AsVal_int(obj1, &val2);
33296 if (!SWIG_IsOK(ecode2)) {
33297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33298 }
33299 arg2 = static_cast< wxDragResult >(val2);
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 (arg1)->SetDefaultAction(arg2);
33303 wxPyEndAllowThreads(__tstate);
33304 if (PyErr_Occurred()) SWIG_fail;
33305 }
33306 resultobj = SWIG_Py_Void();
33307 return resultobj;
33308 fail:
33309 return NULL;
33310 }
33311
33312
33313 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33314 PyObject *resultobj = 0;
33315 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33316 wxDragResult result;
33317 void *argp1 = 0 ;
33318 int res1 = 0 ;
33319 PyObject *swig_obj[1] ;
33320
33321 if (!args) SWIG_fail;
33322 swig_obj[0] = args;
33323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33324 if (!SWIG_IsOK(res1)) {
33325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33326 }
33327 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 result = (wxDragResult)(arg1)->GetDefaultAction();
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 resultobj = SWIG_From_int(static_cast< int >(result));
33335 return resultobj;
33336 fail:
33337 return NULL;
33338 }
33339
33340
33341 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33342 PyObject *obj;
33343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33344 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33345 return SWIG_Py_Void();
33346 }
33347
33348 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33349 return SWIG_Python_InitShadowInstance(args);
33350 }
33351
33352 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33353 PyObject *resultobj = 0;
33354 wxPyTextDropTarget *result = 0 ;
33355
33356 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33360 wxPyEndAllowThreads(__tstate);
33361 if (PyErr_Occurred()) SWIG_fail;
33362 }
33363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33364 return resultobj;
33365 fail:
33366 return NULL;
33367 }
33368
33369
33370 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33371 PyObject *resultobj = 0;
33372 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33373 PyObject *arg2 = (PyObject *) 0 ;
33374 PyObject *arg3 = (PyObject *) 0 ;
33375 void *argp1 = 0 ;
33376 int res1 = 0 ;
33377 PyObject * obj0 = 0 ;
33378 PyObject * obj1 = 0 ;
33379 PyObject * obj2 = 0 ;
33380 char * kwnames[] = {
33381 (char *) "self",(char *) "self",(char *) "_class", NULL
33382 };
33383
33384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33386 if (!SWIG_IsOK(res1)) {
33387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33388 }
33389 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33390 arg2 = obj1;
33391 arg3 = obj2;
33392 {
33393 PyThreadState* __tstate = wxPyBeginAllowThreads();
33394 (arg1)->_setCallbackInfo(arg2,arg3);
33395 wxPyEndAllowThreads(__tstate);
33396 if (PyErr_Occurred()) SWIG_fail;
33397 }
33398 resultobj = SWIG_Py_Void();
33399 return resultobj;
33400 fail:
33401 return NULL;
33402 }
33403
33404
33405 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33406 PyObject *resultobj = 0;
33407 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33408 int arg2 ;
33409 int arg3 ;
33410 wxString *arg4 = 0 ;
33411 bool result;
33412 void *argp1 = 0 ;
33413 int res1 = 0 ;
33414 int val2 ;
33415 int ecode2 = 0 ;
33416 int val3 ;
33417 int ecode3 = 0 ;
33418 bool temp4 = false ;
33419 PyObject * obj0 = 0 ;
33420 PyObject * obj1 = 0 ;
33421 PyObject * obj2 = 0 ;
33422 PyObject * obj3 = 0 ;
33423 char * kwnames[] = {
33424 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33425 };
33426
33427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33429 if (!SWIG_IsOK(res1)) {
33430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33431 }
33432 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33433 ecode2 = SWIG_AsVal_int(obj1, &val2);
33434 if (!SWIG_IsOK(ecode2)) {
33435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33436 }
33437 arg2 = static_cast< int >(val2);
33438 ecode3 = SWIG_AsVal_int(obj2, &val3);
33439 if (!SWIG_IsOK(ecode3)) {
33440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33441 }
33442 arg3 = static_cast< int >(val3);
33443 {
33444 arg4 = wxString_in_helper(obj3);
33445 if (arg4 == NULL) SWIG_fail;
33446 temp4 = true;
33447 }
33448 {
33449 PyThreadState* __tstate = wxPyBeginAllowThreads();
33450 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33451 wxPyEndAllowThreads(__tstate);
33452 if (PyErr_Occurred()) SWIG_fail;
33453 }
33454 {
33455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33456 }
33457 {
33458 if (temp4)
33459 delete arg4;
33460 }
33461 return resultobj;
33462 fail:
33463 {
33464 if (temp4)
33465 delete arg4;
33466 }
33467 return NULL;
33468 }
33469
33470
33471 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33472 PyObject *resultobj = 0;
33473 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33474 int arg2 ;
33475 int arg3 ;
33476 wxDragResult arg4 ;
33477 wxDragResult result;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 int val2 ;
33481 int ecode2 = 0 ;
33482 int val3 ;
33483 int ecode3 = 0 ;
33484 int val4 ;
33485 int ecode4 = 0 ;
33486 PyObject * obj0 = 0 ;
33487 PyObject * obj1 = 0 ;
33488 PyObject * obj2 = 0 ;
33489 PyObject * obj3 = 0 ;
33490 char * kwnames[] = {
33491 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33492 };
33493
33494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33496 if (!SWIG_IsOK(res1)) {
33497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33498 }
33499 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33500 ecode2 = SWIG_AsVal_int(obj1, &val2);
33501 if (!SWIG_IsOK(ecode2)) {
33502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33503 }
33504 arg2 = static_cast< int >(val2);
33505 ecode3 = SWIG_AsVal_int(obj2, &val3);
33506 if (!SWIG_IsOK(ecode3)) {
33507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33508 }
33509 arg3 = static_cast< int >(val3);
33510 ecode4 = SWIG_AsVal_int(obj3, &val4);
33511 if (!SWIG_IsOK(ecode4)) {
33512 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33513 }
33514 arg4 = static_cast< wxDragResult >(val4);
33515 {
33516 PyThreadState* __tstate = wxPyBeginAllowThreads();
33517 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33518 wxPyEndAllowThreads(__tstate);
33519 if (PyErr_Occurred()) SWIG_fail;
33520 }
33521 resultobj = SWIG_From_int(static_cast< int >(result));
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33529 PyObject *resultobj = 0;
33530 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33531 int arg2 ;
33532 int arg3 ;
33533 wxDragResult arg4 ;
33534 wxDragResult result;
33535 void *argp1 = 0 ;
33536 int res1 = 0 ;
33537 int val2 ;
33538 int ecode2 = 0 ;
33539 int val3 ;
33540 int ecode3 = 0 ;
33541 int val4 ;
33542 int ecode4 = 0 ;
33543 PyObject * obj0 = 0 ;
33544 PyObject * obj1 = 0 ;
33545 PyObject * obj2 = 0 ;
33546 PyObject * obj3 = 0 ;
33547 char * kwnames[] = {
33548 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33549 };
33550
33551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33553 if (!SWIG_IsOK(res1)) {
33554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33555 }
33556 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33557 ecode2 = SWIG_AsVal_int(obj1, &val2);
33558 if (!SWIG_IsOK(ecode2)) {
33559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33560 }
33561 arg2 = static_cast< int >(val2);
33562 ecode3 = SWIG_AsVal_int(obj2, &val3);
33563 if (!SWIG_IsOK(ecode3)) {
33564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33565 }
33566 arg3 = static_cast< int >(val3);
33567 ecode4 = SWIG_AsVal_int(obj3, &val4);
33568 if (!SWIG_IsOK(ecode4)) {
33569 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33570 }
33571 arg4 = static_cast< wxDragResult >(val4);
33572 {
33573 PyThreadState* __tstate = wxPyBeginAllowThreads();
33574 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33575 wxPyEndAllowThreads(__tstate);
33576 if (PyErr_Occurred()) SWIG_fail;
33577 }
33578 resultobj = SWIG_From_int(static_cast< int >(result));
33579 return resultobj;
33580 fail:
33581 return NULL;
33582 }
33583
33584
33585 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33586 PyObject *resultobj = 0;
33587 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33588 void *argp1 = 0 ;
33589 int res1 = 0 ;
33590 PyObject *swig_obj[1] ;
33591
33592 if (!args) SWIG_fail;
33593 swig_obj[0] = args;
33594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33595 if (!SWIG_IsOK(res1)) {
33596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33597 }
33598 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 (arg1)->OnLeave();
33602 wxPyEndAllowThreads(__tstate);
33603 if (PyErr_Occurred()) SWIG_fail;
33604 }
33605 resultobj = SWIG_Py_Void();
33606 return resultobj;
33607 fail:
33608 return NULL;
33609 }
33610
33611
33612 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33613 PyObject *resultobj = 0;
33614 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33615 int arg2 ;
33616 int arg3 ;
33617 bool result;
33618 void *argp1 = 0 ;
33619 int res1 = 0 ;
33620 int val2 ;
33621 int ecode2 = 0 ;
33622 int val3 ;
33623 int ecode3 = 0 ;
33624 PyObject * obj0 = 0 ;
33625 PyObject * obj1 = 0 ;
33626 PyObject * obj2 = 0 ;
33627 char * kwnames[] = {
33628 (char *) "self",(char *) "x",(char *) "y", NULL
33629 };
33630
33631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33633 if (!SWIG_IsOK(res1)) {
33634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33635 }
33636 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33637 ecode2 = SWIG_AsVal_int(obj1, &val2);
33638 if (!SWIG_IsOK(ecode2)) {
33639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33640 }
33641 arg2 = static_cast< int >(val2);
33642 ecode3 = SWIG_AsVal_int(obj2, &val3);
33643 if (!SWIG_IsOK(ecode3)) {
33644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33645 }
33646 arg3 = static_cast< int >(val3);
33647 {
33648 PyThreadState* __tstate = wxPyBeginAllowThreads();
33649 result = (bool)(arg1)->OnDrop(arg2,arg3);
33650 wxPyEndAllowThreads(__tstate);
33651 if (PyErr_Occurred()) SWIG_fail;
33652 }
33653 {
33654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33655 }
33656 return resultobj;
33657 fail:
33658 return NULL;
33659 }
33660
33661
33662 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33663 PyObject *resultobj = 0;
33664 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33665 int arg2 ;
33666 int arg3 ;
33667 wxDragResult arg4 ;
33668 wxDragResult result;
33669 void *argp1 = 0 ;
33670 int res1 = 0 ;
33671 int val2 ;
33672 int ecode2 = 0 ;
33673 int val3 ;
33674 int ecode3 = 0 ;
33675 int val4 ;
33676 int ecode4 = 0 ;
33677 PyObject * obj0 = 0 ;
33678 PyObject * obj1 = 0 ;
33679 PyObject * obj2 = 0 ;
33680 PyObject * obj3 = 0 ;
33681 char * kwnames[] = {
33682 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33683 };
33684
33685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33687 if (!SWIG_IsOK(res1)) {
33688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33689 }
33690 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33691 ecode2 = SWIG_AsVal_int(obj1, &val2);
33692 if (!SWIG_IsOK(ecode2)) {
33693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33694 }
33695 arg2 = static_cast< int >(val2);
33696 ecode3 = SWIG_AsVal_int(obj2, &val3);
33697 if (!SWIG_IsOK(ecode3)) {
33698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33699 }
33700 arg3 = static_cast< int >(val3);
33701 ecode4 = SWIG_AsVal_int(obj3, &val4);
33702 if (!SWIG_IsOK(ecode4)) {
33703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33704 }
33705 arg4 = static_cast< wxDragResult >(val4);
33706 {
33707 PyThreadState* __tstate = wxPyBeginAllowThreads();
33708 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33709 wxPyEndAllowThreads(__tstate);
33710 if (PyErr_Occurred()) SWIG_fail;
33711 }
33712 resultobj = SWIG_From_int(static_cast< int >(result));
33713 return resultobj;
33714 fail:
33715 return NULL;
33716 }
33717
33718
33719 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33720 PyObject *obj;
33721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33722 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33723 return SWIG_Py_Void();
33724 }
33725
33726 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33727 return SWIG_Python_InitShadowInstance(args);
33728 }
33729
33730 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33731 PyObject *resultobj = 0;
33732 wxPyFileDropTarget *result = 0 ;
33733
33734 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33735 {
33736 PyThreadState* __tstate = wxPyBeginAllowThreads();
33737 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33738 wxPyEndAllowThreads(__tstate);
33739 if (PyErr_Occurred()) SWIG_fail;
33740 }
33741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33742 return resultobj;
33743 fail:
33744 return NULL;
33745 }
33746
33747
33748 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33749 PyObject *resultobj = 0;
33750 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33751 PyObject *arg2 = (PyObject *) 0 ;
33752 PyObject *arg3 = (PyObject *) 0 ;
33753 void *argp1 = 0 ;
33754 int res1 = 0 ;
33755 PyObject * obj0 = 0 ;
33756 PyObject * obj1 = 0 ;
33757 PyObject * obj2 = 0 ;
33758 char * kwnames[] = {
33759 (char *) "self",(char *) "self",(char *) "_class", NULL
33760 };
33761
33762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33764 if (!SWIG_IsOK(res1)) {
33765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33766 }
33767 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33768 arg2 = obj1;
33769 arg3 = obj2;
33770 {
33771 PyThreadState* __tstate = wxPyBeginAllowThreads();
33772 (arg1)->_setCallbackInfo(arg2,arg3);
33773 wxPyEndAllowThreads(__tstate);
33774 if (PyErr_Occurred()) SWIG_fail;
33775 }
33776 resultobj = SWIG_Py_Void();
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33784 PyObject *resultobj = 0;
33785 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33786 int arg2 ;
33787 int arg3 ;
33788 wxArrayString *arg4 = 0 ;
33789 bool result;
33790 void *argp1 = 0 ;
33791 int res1 = 0 ;
33792 int val2 ;
33793 int ecode2 = 0 ;
33794 int val3 ;
33795 int ecode3 = 0 ;
33796 bool temp4 = false ;
33797 PyObject * obj0 = 0 ;
33798 PyObject * obj1 = 0 ;
33799 PyObject * obj2 = 0 ;
33800 PyObject * obj3 = 0 ;
33801 char * kwnames[] = {
33802 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33803 };
33804
33805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33807 if (!SWIG_IsOK(res1)) {
33808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33809 }
33810 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33811 ecode2 = SWIG_AsVal_int(obj1, &val2);
33812 if (!SWIG_IsOK(ecode2)) {
33813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33814 }
33815 arg2 = static_cast< int >(val2);
33816 ecode3 = SWIG_AsVal_int(obj2, &val3);
33817 if (!SWIG_IsOK(ecode3)) {
33818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33819 }
33820 arg3 = static_cast< int >(val3);
33821 {
33822 if (! PySequence_Check(obj3)) {
33823 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33824 SWIG_fail;
33825 }
33826 arg4 = new wxArrayString;
33827 temp4 = true;
33828 int i, len=PySequence_Length(obj3);
33829 for (i=0; i<len; i++) {
33830 PyObject* item = PySequence_GetItem(obj3, i);
33831 wxString* s = wxString_in_helper(item);
33832 if (PyErr_Occurred()) SWIG_fail;
33833 arg4->Add(*s);
33834 delete s;
33835 Py_DECREF(item);
33836 }
33837 }
33838 {
33839 PyThreadState* __tstate = wxPyBeginAllowThreads();
33840 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33841 wxPyEndAllowThreads(__tstate);
33842 if (PyErr_Occurred()) SWIG_fail;
33843 }
33844 {
33845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33846 }
33847 {
33848 if (temp4) delete arg4;
33849 }
33850 return resultobj;
33851 fail:
33852 {
33853 if (temp4) delete arg4;
33854 }
33855 return NULL;
33856 }
33857
33858
33859 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33860 PyObject *resultobj = 0;
33861 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33862 int arg2 ;
33863 int arg3 ;
33864 wxDragResult arg4 ;
33865 wxDragResult result;
33866 void *argp1 = 0 ;
33867 int res1 = 0 ;
33868 int val2 ;
33869 int ecode2 = 0 ;
33870 int val3 ;
33871 int ecode3 = 0 ;
33872 int val4 ;
33873 int ecode4 = 0 ;
33874 PyObject * obj0 = 0 ;
33875 PyObject * obj1 = 0 ;
33876 PyObject * obj2 = 0 ;
33877 PyObject * obj3 = 0 ;
33878 char * kwnames[] = {
33879 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33880 };
33881
33882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33884 if (!SWIG_IsOK(res1)) {
33885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33886 }
33887 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33888 ecode2 = SWIG_AsVal_int(obj1, &val2);
33889 if (!SWIG_IsOK(ecode2)) {
33890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33891 }
33892 arg2 = static_cast< int >(val2);
33893 ecode3 = SWIG_AsVal_int(obj2, &val3);
33894 if (!SWIG_IsOK(ecode3)) {
33895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33896 }
33897 arg3 = static_cast< int >(val3);
33898 ecode4 = SWIG_AsVal_int(obj3, &val4);
33899 if (!SWIG_IsOK(ecode4)) {
33900 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33901 }
33902 arg4 = static_cast< wxDragResult >(val4);
33903 {
33904 PyThreadState* __tstate = wxPyBeginAllowThreads();
33905 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33906 wxPyEndAllowThreads(__tstate);
33907 if (PyErr_Occurred()) SWIG_fail;
33908 }
33909 resultobj = SWIG_From_int(static_cast< int >(result));
33910 return resultobj;
33911 fail:
33912 return NULL;
33913 }
33914
33915
33916 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33917 PyObject *resultobj = 0;
33918 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33919 int arg2 ;
33920 int arg3 ;
33921 wxDragResult arg4 ;
33922 wxDragResult result;
33923 void *argp1 = 0 ;
33924 int res1 = 0 ;
33925 int val2 ;
33926 int ecode2 = 0 ;
33927 int val3 ;
33928 int ecode3 = 0 ;
33929 int val4 ;
33930 int ecode4 = 0 ;
33931 PyObject * obj0 = 0 ;
33932 PyObject * obj1 = 0 ;
33933 PyObject * obj2 = 0 ;
33934 PyObject * obj3 = 0 ;
33935 char * kwnames[] = {
33936 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
33937 };
33938
33939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33941 if (!SWIG_IsOK(res1)) {
33942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33943 }
33944 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33945 ecode2 = SWIG_AsVal_int(obj1, &val2);
33946 if (!SWIG_IsOK(ecode2)) {
33947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33948 }
33949 arg2 = static_cast< int >(val2);
33950 ecode3 = SWIG_AsVal_int(obj2, &val3);
33951 if (!SWIG_IsOK(ecode3)) {
33952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33953 }
33954 arg3 = static_cast< int >(val3);
33955 ecode4 = SWIG_AsVal_int(obj3, &val4);
33956 if (!SWIG_IsOK(ecode4)) {
33957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33958 }
33959 arg4 = static_cast< wxDragResult >(val4);
33960 {
33961 PyThreadState* __tstate = wxPyBeginAllowThreads();
33962 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33963 wxPyEndAllowThreads(__tstate);
33964 if (PyErr_Occurred()) SWIG_fail;
33965 }
33966 resultobj = SWIG_From_int(static_cast< int >(result));
33967 return resultobj;
33968 fail:
33969 return NULL;
33970 }
33971
33972
33973 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33974 PyObject *resultobj = 0;
33975 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33976 void *argp1 = 0 ;
33977 int res1 = 0 ;
33978 PyObject *swig_obj[1] ;
33979
33980 if (!args) SWIG_fail;
33981 swig_obj[0] = args;
33982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33983 if (!SWIG_IsOK(res1)) {
33984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33985 }
33986 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33987 {
33988 PyThreadState* __tstate = wxPyBeginAllowThreads();
33989 (arg1)->OnLeave();
33990 wxPyEndAllowThreads(__tstate);
33991 if (PyErr_Occurred()) SWIG_fail;
33992 }
33993 resultobj = SWIG_Py_Void();
33994 return resultobj;
33995 fail:
33996 return NULL;
33997 }
33998
33999
34000 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34001 PyObject *resultobj = 0;
34002 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34003 int arg2 ;
34004 int arg3 ;
34005 bool result;
34006 void *argp1 = 0 ;
34007 int res1 = 0 ;
34008 int val2 ;
34009 int ecode2 = 0 ;
34010 int val3 ;
34011 int ecode3 = 0 ;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 PyObject * obj2 = 0 ;
34015 char * kwnames[] = {
34016 (char *) "self",(char *) "x",(char *) "y", NULL
34017 };
34018
34019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34023 }
34024 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34025 ecode2 = SWIG_AsVal_int(obj1, &val2);
34026 if (!SWIG_IsOK(ecode2)) {
34027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
34028 }
34029 arg2 = static_cast< int >(val2);
34030 ecode3 = SWIG_AsVal_int(obj2, &val3);
34031 if (!SWIG_IsOK(ecode3)) {
34032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
34033 }
34034 arg3 = static_cast< int >(val3);
34035 {
34036 PyThreadState* __tstate = wxPyBeginAllowThreads();
34037 result = (bool)(arg1)->OnDrop(arg2,arg3);
34038 wxPyEndAllowThreads(__tstate);
34039 if (PyErr_Occurred()) SWIG_fail;
34040 }
34041 {
34042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34043 }
34044 return resultobj;
34045 fail:
34046 return NULL;
34047 }
34048
34049
34050 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34051 PyObject *resultobj = 0;
34052 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
34053 int arg2 ;
34054 int arg3 ;
34055 wxDragResult arg4 ;
34056 wxDragResult result;
34057 void *argp1 = 0 ;
34058 int res1 = 0 ;
34059 int val2 ;
34060 int ecode2 = 0 ;
34061 int val3 ;
34062 int ecode3 = 0 ;
34063 int val4 ;
34064 int ecode4 = 0 ;
34065 PyObject * obj0 = 0 ;
34066 PyObject * obj1 = 0 ;
34067 PyObject * obj2 = 0 ;
34068 PyObject * obj3 = 0 ;
34069 char * kwnames[] = {
34070 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
34071 };
34072
34073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
34075 if (!SWIG_IsOK(res1)) {
34076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
34077 }
34078 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
34079 ecode2 = SWIG_AsVal_int(obj1, &val2);
34080 if (!SWIG_IsOK(ecode2)) {
34081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
34082 }
34083 arg2 = static_cast< int >(val2);
34084 ecode3 = SWIG_AsVal_int(obj2, &val3);
34085 if (!SWIG_IsOK(ecode3)) {
34086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
34087 }
34088 arg3 = static_cast< int >(val3);
34089 ecode4 = SWIG_AsVal_int(obj3, &val4);
34090 if (!SWIG_IsOK(ecode4)) {
34091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
34092 }
34093 arg4 = static_cast< wxDragResult >(val4);
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 resultobj = SWIG_From_int(static_cast< int >(result));
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34108 PyObject *obj;
34109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34110 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
34111 return SWIG_Py_Void();
34112 }
34113
34114 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34115 return SWIG_Python_InitShadowInstance(args);
34116 }
34117
34118 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34119 PyObject *resultobj = 0;
34120 wxClipboard *result = 0 ;
34121
34122 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 result = (wxClipboard *)new wxClipboard();
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34137 PyObject *resultobj = 0;
34138 wxClipboard *arg1 = (wxClipboard *) 0 ;
34139 void *argp1 = 0 ;
34140 int res1 = 0 ;
34141 PyObject *swig_obj[1] ;
34142
34143 if (!args) SWIG_fail;
34144 swig_obj[0] = args;
34145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
34146 if (!SWIG_IsOK(res1)) {
34147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
34148 }
34149 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34150 {
34151 PyThreadState* __tstate = wxPyBeginAllowThreads();
34152 delete arg1;
34153
34154 wxPyEndAllowThreads(__tstate);
34155 if (PyErr_Occurred()) SWIG_fail;
34156 }
34157 resultobj = SWIG_Py_Void();
34158 return resultobj;
34159 fail:
34160 return NULL;
34161 }
34162
34163
34164 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34165 PyObject *resultobj = 0;
34166 wxClipboard *arg1 = (wxClipboard *) 0 ;
34167 bool result;
34168 void *argp1 = 0 ;
34169 int res1 = 0 ;
34170 PyObject *swig_obj[1] ;
34171
34172 if (!args) SWIG_fail;
34173 swig_obj[0] = args;
34174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34175 if (!SWIG_IsOK(res1)) {
34176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
34177 }
34178 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34179 {
34180 PyThreadState* __tstate = wxPyBeginAllowThreads();
34181 result = (bool)(arg1)->Open();
34182 wxPyEndAllowThreads(__tstate);
34183 if (PyErr_Occurred()) SWIG_fail;
34184 }
34185 {
34186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34187 }
34188 return resultobj;
34189 fail:
34190 return NULL;
34191 }
34192
34193
34194 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34195 PyObject *resultobj = 0;
34196 wxClipboard *arg1 = (wxClipboard *) 0 ;
34197 void *argp1 = 0 ;
34198 int res1 = 0 ;
34199 PyObject *swig_obj[1] ;
34200
34201 if (!args) SWIG_fail;
34202 swig_obj[0] = args;
34203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34204 if (!SWIG_IsOK(res1)) {
34205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
34206 }
34207 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34208 {
34209 PyThreadState* __tstate = wxPyBeginAllowThreads();
34210 (arg1)->Close();
34211 wxPyEndAllowThreads(__tstate);
34212 if (PyErr_Occurred()) SWIG_fail;
34213 }
34214 resultobj = SWIG_Py_Void();
34215 return resultobj;
34216 fail:
34217 return NULL;
34218 }
34219
34220
34221 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34222 PyObject *resultobj = 0;
34223 wxClipboard *arg1 = (wxClipboard *) 0 ;
34224 bool result;
34225 void *argp1 = 0 ;
34226 int res1 = 0 ;
34227 PyObject *swig_obj[1] ;
34228
34229 if (!args) SWIG_fail;
34230 swig_obj[0] = args;
34231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34232 if (!SWIG_IsOK(res1)) {
34233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34234 }
34235 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34236 {
34237 PyThreadState* __tstate = wxPyBeginAllowThreads();
34238 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34239 wxPyEndAllowThreads(__tstate);
34240 if (PyErr_Occurred()) SWIG_fail;
34241 }
34242 {
34243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34244 }
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34252 PyObject *resultobj = 0;
34253 wxClipboard *arg1 = (wxClipboard *) 0 ;
34254 wxDataObject *arg2 = (wxDataObject *) 0 ;
34255 bool result;
34256 void *argp1 = 0 ;
34257 int res1 = 0 ;
34258 int res2 = 0 ;
34259 PyObject * obj0 = 0 ;
34260 PyObject * obj1 = 0 ;
34261 char * kwnames[] = {
34262 (char *) "self",(char *) "data", NULL
34263 };
34264
34265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34267 if (!SWIG_IsOK(res1)) {
34268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34269 }
34270 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34271 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34272 if (!SWIG_IsOK(res2)) {
34273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34274 }
34275 {
34276 PyThreadState* __tstate = wxPyBeginAllowThreads();
34277 result = (bool)(arg1)->AddData(arg2);
34278 wxPyEndAllowThreads(__tstate);
34279 if (PyErr_Occurred()) SWIG_fail;
34280 }
34281 {
34282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34283 }
34284 return resultobj;
34285 fail:
34286 return NULL;
34287 }
34288
34289
34290 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34291 PyObject *resultobj = 0;
34292 wxClipboard *arg1 = (wxClipboard *) 0 ;
34293 wxDataObject *arg2 = (wxDataObject *) 0 ;
34294 bool result;
34295 void *argp1 = 0 ;
34296 int res1 = 0 ;
34297 int res2 = 0 ;
34298 PyObject * obj0 = 0 ;
34299 PyObject * obj1 = 0 ;
34300 char * kwnames[] = {
34301 (char *) "self",(char *) "data", NULL
34302 };
34303
34304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34306 if (!SWIG_IsOK(res1)) {
34307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34308 }
34309 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34310 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34311 if (!SWIG_IsOK(res2)) {
34312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34313 }
34314 {
34315 PyThreadState* __tstate = wxPyBeginAllowThreads();
34316 result = (bool)(arg1)->SetData(arg2);
34317 wxPyEndAllowThreads(__tstate);
34318 if (PyErr_Occurred()) SWIG_fail;
34319 }
34320 {
34321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34322 }
34323 return resultobj;
34324 fail:
34325 return NULL;
34326 }
34327
34328
34329 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34330 PyObject *resultobj = 0;
34331 wxClipboard *arg1 = (wxClipboard *) 0 ;
34332 wxDataFormat *arg2 = 0 ;
34333 bool result;
34334 void *argp1 = 0 ;
34335 int res1 = 0 ;
34336 void *argp2 = 0 ;
34337 int res2 = 0 ;
34338 PyObject * obj0 = 0 ;
34339 PyObject * obj1 = 0 ;
34340 char * kwnames[] = {
34341 (char *) "self",(char *) "format", NULL
34342 };
34343
34344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34346 if (!SWIG_IsOK(res1)) {
34347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34348 }
34349 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34351 if (!SWIG_IsOK(res2)) {
34352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34353 }
34354 if (!argp2) {
34355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34356 }
34357 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34358 {
34359 PyThreadState* __tstate = wxPyBeginAllowThreads();
34360 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34361 wxPyEndAllowThreads(__tstate);
34362 if (PyErr_Occurred()) SWIG_fail;
34363 }
34364 {
34365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34366 }
34367 return resultobj;
34368 fail:
34369 return NULL;
34370 }
34371
34372
34373 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34374 PyObject *resultobj = 0;
34375 wxClipboard *arg1 = (wxClipboard *) 0 ;
34376 wxDataObject *arg2 = 0 ;
34377 bool result;
34378 void *argp1 = 0 ;
34379 int res1 = 0 ;
34380 void *argp2 = 0 ;
34381 int res2 = 0 ;
34382 PyObject * obj0 = 0 ;
34383 PyObject * obj1 = 0 ;
34384 char * kwnames[] = {
34385 (char *) "self",(char *) "data", NULL
34386 };
34387
34388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34390 if (!SWIG_IsOK(res1)) {
34391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34392 }
34393 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34394 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34395 if (!SWIG_IsOK(res2)) {
34396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34397 }
34398 if (!argp2) {
34399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34400 }
34401 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34402 {
34403 PyThreadState* __tstate = wxPyBeginAllowThreads();
34404 result = (bool)(arg1)->GetData(*arg2);
34405 wxPyEndAllowThreads(__tstate);
34406 if (PyErr_Occurred()) SWIG_fail;
34407 }
34408 {
34409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34410 }
34411 return resultobj;
34412 fail:
34413 return NULL;
34414 }
34415
34416
34417 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34418 PyObject *resultobj = 0;
34419 wxClipboard *arg1 = (wxClipboard *) 0 ;
34420 void *argp1 = 0 ;
34421 int res1 = 0 ;
34422 PyObject *swig_obj[1] ;
34423
34424 if (!args) SWIG_fail;
34425 swig_obj[0] = args;
34426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34427 if (!SWIG_IsOK(res1)) {
34428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34429 }
34430 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34431 {
34432 PyThreadState* __tstate = wxPyBeginAllowThreads();
34433 (arg1)->Clear();
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 resultobj = SWIG_Py_Void();
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34445 PyObject *resultobj = 0;
34446 wxClipboard *arg1 = (wxClipboard *) 0 ;
34447 bool result;
34448 void *argp1 = 0 ;
34449 int res1 = 0 ;
34450 PyObject *swig_obj[1] ;
34451
34452 if (!args) SWIG_fail;
34453 swig_obj[0] = args;
34454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34455 if (!SWIG_IsOK(res1)) {
34456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34457 }
34458 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34459 {
34460 PyThreadState* __tstate = wxPyBeginAllowThreads();
34461 result = (bool)(arg1)->Flush();
34462 wxPyEndAllowThreads(__tstate);
34463 if (PyErr_Occurred()) SWIG_fail;
34464 }
34465 {
34466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34467 }
34468 return resultobj;
34469 fail:
34470 return NULL;
34471 }
34472
34473
34474 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34475 PyObject *resultobj = 0;
34476 wxClipboard *arg1 = (wxClipboard *) 0 ;
34477 bool arg2 = (bool) true ;
34478 void *argp1 = 0 ;
34479 int res1 = 0 ;
34480 bool val2 ;
34481 int ecode2 = 0 ;
34482 PyObject * obj0 = 0 ;
34483 PyObject * obj1 = 0 ;
34484 char * kwnames[] = {
34485 (char *) "self",(char *) "primary", NULL
34486 };
34487
34488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34490 if (!SWIG_IsOK(res1)) {
34491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34492 }
34493 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34494 if (obj1) {
34495 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34496 if (!SWIG_IsOK(ecode2)) {
34497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34498 }
34499 arg2 = static_cast< bool >(val2);
34500 }
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 (arg1)->UsePrimarySelection(arg2);
34504 wxPyEndAllowThreads(__tstate);
34505 if (PyErr_Occurred()) SWIG_fail;
34506 }
34507 resultobj = SWIG_Py_Void();
34508 return resultobj;
34509 fail:
34510 return NULL;
34511 }
34512
34513
34514 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34515 PyObject *resultobj = 0;
34516 wxClipboard *result = 0 ;
34517
34518 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34519 {
34520 PyThreadState* __tstate = wxPyBeginAllowThreads();
34521 result = (wxClipboard *)wxClipboard::Get();
34522 wxPyEndAllowThreads(__tstate);
34523 if (PyErr_Occurred()) SWIG_fail;
34524 }
34525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34526 return resultobj;
34527 fail:
34528 return NULL;
34529 }
34530
34531
34532 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34533 PyObject *obj;
34534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34535 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34536 return SWIG_Py_Void();
34537 }
34538
34539 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34540 return SWIG_Python_InitShadowInstance(args);
34541 }
34542
34543 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34544 PyObject *resultobj = 0;
34545 wxClipboard *arg1 = (wxClipboard *) NULL ;
34546 wxClipboardLocker *result = 0 ;
34547 void *argp1 = 0 ;
34548 int res1 = 0 ;
34549 PyObject * obj0 = 0 ;
34550 char * kwnames[] = {
34551 (char *) "clipboard", NULL
34552 };
34553
34554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34555 if (obj0) {
34556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34557 if (!SWIG_IsOK(res1)) {
34558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34559 }
34560 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34561 }
34562 {
34563 PyThreadState* __tstate = wxPyBeginAllowThreads();
34564 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34565 wxPyEndAllowThreads(__tstate);
34566 if (PyErr_Occurred()) SWIG_fail;
34567 }
34568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34569 return resultobj;
34570 fail:
34571 return NULL;
34572 }
34573
34574
34575 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34576 PyObject *resultobj = 0;
34577 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34578 void *argp1 = 0 ;
34579 int res1 = 0 ;
34580 PyObject *swig_obj[1] ;
34581
34582 if (!args) SWIG_fail;
34583 swig_obj[0] = args;
34584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34585 if (!SWIG_IsOK(res1)) {
34586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34587 }
34588 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34589 {
34590 PyThreadState* __tstate = wxPyBeginAllowThreads();
34591 delete arg1;
34592
34593 wxPyEndAllowThreads(__tstate);
34594 if (PyErr_Occurred()) SWIG_fail;
34595 }
34596 resultobj = SWIG_Py_Void();
34597 return resultobj;
34598 fail:
34599 return NULL;
34600 }
34601
34602
34603 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34604 PyObject *resultobj = 0;
34605 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34606 bool result;
34607 void *argp1 = 0 ;
34608 int res1 = 0 ;
34609 PyObject *swig_obj[1] ;
34610
34611 if (!args) SWIG_fail;
34612 swig_obj[0] = args;
34613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34614 if (!SWIG_IsOK(res1)) {
34615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34616 }
34617 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34618 {
34619 PyThreadState* __tstate = wxPyBeginAllowThreads();
34620 result = (bool)wxClipboardLocker___nonzero__(arg1);
34621 wxPyEndAllowThreads(__tstate);
34622 if (PyErr_Occurred()) SWIG_fail;
34623 }
34624 {
34625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34626 }
34627 return resultobj;
34628 fail:
34629 return NULL;
34630 }
34631
34632
34633 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34634 PyObject *obj;
34635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34636 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34637 return SWIG_Py_Void();
34638 }
34639
34640 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34641 return SWIG_Python_InitShadowInstance(args);
34642 }
34643
34644 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34645 PyObject *resultobj = 0;
34646 int arg1 = (int) 0 ;
34647 int arg2 = (int) 0 ;
34648 int arg3 = (int) 0 ;
34649 int arg4 = (int) 0 ;
34650 wxVideoMode *result = 0 ;
34651 int val1 ;
34652 int ecode1 = 0 ;
34653 int val2 ;
34654 int ecode2 = 0 ;
34655 int val3 ;
34656 int ecode3 = 0 ;
34657 int val4 ;
34658 int ecode4 = 0 ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 PyObject * obj2 = 0 ;
34662 PyObject * obj3 = 0 ;
34663 char * kwnames[] = {
34664 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34665 };
34666
34667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34668 if (obj0) {
34669 ecode1 = SWIG_AsVal_int(obj0, &val1);
34670 if (!SWIG_IsOK(ecode1)) {
34671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34672 }
34673 arg1 = static_cast< int >(val1);
34674 }
34675 if (obj1) {
34676 ecode2 = SWIG_AsVal_int(obj1, &val2);
34677 if (!SWIG_IsOK(ecode2)) {
34678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34679 }
34680 arg2 = static_cast< int >(val2);
34681 }
34682 if (obj2) {
34683 ecode3 = SWIG_AsVal_int(obj2, &val3);
34684 if (!SWIG_IsOK(ecode3)) {
34685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34686 }
34687 arg3 = static_cast< int >(val3);
34688 }
34689 if (obj3) {
34690 ecode4 = SWIG_AsVal_int(obj3, &val4);
34691 if (!SWIG_IsOK(ecode4)) {
34692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34693 }
34694 arg4 = static_cast< int >(val4);
34695 }
34696 {
34697 PyThreadState* __tstate = wxPyBeginAllowThreads();
34698 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34699 wxPyEndAllowThreads(__tstate);
34700 if (PyErr_Occurred()) SWIG_fail;
34701 }
34702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34703 return resultobj;
34704 fail:
34705 return NULL;
34706 }
34707
34708
34709 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34710 PyObject *resultobj = 0;
34711 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34712 void *argp1 = 0 ;
34713 int res1 = 0 ;
34714 PyObject *swig_obj[1] ;
34715
34716 if (!args) SWIG_fail;
34717 swig_obj[0] = args;
34718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34719 if (!SWIG_IsOK(res1)) {
34720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34721 }
34722 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34723 {
34724 PyThreadState* __tstate = wxPyBeginAllowThreads();
34725 delete arg1;
34726
34727 wxPyEndAllowThreads(__tstate);
34728 if (PyErr_Occurred()) SWIG_fail;
34729 }
34730 resultobj = SWIG_Py_Void();
34731 return resultobj;
34732 fail:
34733 return NULL;
34734 }
34735
34736
34737 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34738 PyObject *resultobj = 0;
34739 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34740 wxVideoMode *arg2 = 0 ;
34741 bool result;
34742 void *argp1 = 0 ;
34743 int res1 = 0 ;
34744 void *argp2 = 0 ;
34745 int res2 = 0 ;
34746 PyObject * obj0 = 0 ;
34747 PyObject * obj1 = 0 ;
34748 char * kwnames[] = {
34749 (char *) "self",(char *) "other", NULL
34750 };
34751
34752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34754 if (!SWIG_IsOK(res1)) {
34755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34756 }
34757 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34758 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34759 if (!SWIG_IsOK(res2)) {
34760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34761 }
34762 if (!argp2) {
34763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34764 }
34765 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34766 {
34767 PyThreadState* __tstate = wxPyBeginAllowThreads();
34768 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34769 wxPyEndAllowThreads(__tstate);
34770 if (PyErr_Occurred()) SWIG_fail;
34771 }
34772 {
34773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34774 }
34775 return resultobj;
34776 fail:
34777 return NULL;
34778 }
34779
34780
34781 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34782 PyObject *resultobj = 0;
34783 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34784 int result;
34785 void *argp1 = 0 ;
34786 int res1 = 0 ;
34787 PyObject *swig_obj[1] ;
34788
34789 if (!args) SWIG_fail;
34790 swig_obj[0] = args;
34791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34792 if (!SWIG_IsOK(res1)) {
34793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34794 }
34795 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34796 {
34797 PyThreadState* __tstate = wxPyBeginAllowThreads();
34798 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34799 wxPyEndAllowThreads(__tstate);
34800 if (PyErr_Occurred()) SWIG_fail;
34801 }
34802 resultobj = SWIG_From_int(static_cast< int >(result));
34803 return resultobj;
34804 fail:
34805 return NULL;
34806 }
34807
34808
34809 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34810 PyObject *resultobj = 0;
34811 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34812 int result;
34813 void *argp1 = 0 ;
34814 int res1 = 0 ;
34815 PyObject *swig_obj[1] ;
34816
34817 if (!args) SWIG_fail;
34818 swig_obj[0] = args;
34819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34820 if (!SWIG_IsOK(res1)) {
34821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34822 }
34823 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34824 {
34825 PyThreadState* __tstate = wxPyBeginAllowThreads();
34826 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34827 wxPyEndAllowThreads(__tstate);
34828 if (PyErr_Occurred()) SWIG_fail;
34829 }
34830 resultobj = SWIG_From_int(static_cast< int >(result));
34831 return resultobj;
34832 fail:
34833 return NULL;
34834 }
34835
34836
34837 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34838 PyObject *resultobj = 0;
34839 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34840 int result;
34841 void *argp1 = 0 ;
34842 int res1 = 0 ;
34843 PyObject *swig_obj[1] ;
34844
34845 if (!args) SWIG_fail;
34846 swig_obj[0] = args;
34847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34848 if (!SWIG_IsOK(res1)) {
34849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34850 }
34851 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34852 {
34853 PyThreadState* __tstate = wxPyBeginAllowThreads();
34854 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34855 wxPyEndAllowThreads(__tstate);
34856 if (PyErr_Occurred()) SWIG_fail;
34857 }
34858 resultobj = SWIG_From_int(static_cast< int >(result));
34859 return resultobj;
34860 fail:
34861 return NULL;
34862 }
34863
34864
34865 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34866 PyObject *resultobj = 0;
34867 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34868 bool result;
34869 void *argp1 = 0 ;
34870 int res1 = 0 ;
34871 PyObject *swig_obj[1] ;
34872
34873 if (!args) SWIG_fail;
34874 swig_obj[0] = args;
34875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34876 if (!SWIG_IsOK(res1)) {
34877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34878 }
34879 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34880 {
34881 PyThreadState* __tstate = wxPyBeginAllowThreads();
34882 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34883 wxPyEndAllowThreads(__tstate);
34884 if (PyErr_Occurred()) SWIG_fail;
34885 }
34886 {
34887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34888 }
34889 return resultobj;
34890 fail:
34891 return NULL;
34892 }
34893
34894
34895 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34896 PyObject *resultobj = 0;
34897 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34898 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34899 bool result;
34900 void *argp1 = 0 ;
34901 int res1 = 0 ;
34902 void *argp2 = 0 ;
34903 int res2 = 0 ;
34904 PyObject * obj0 = 0 ;
34905 PyObject * obj1 = 0 ;
34906 char * kwnames[] = {
34907 (char *) "self",(char *) "other", NULL
34908 };
34909
34910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34912 if (!SWIG_IsOK(res1)) {
34913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34914 }
34915 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34916 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34917 if (!SWIG_IsOK(res2)) {
34918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34919 }
34920 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34921 {
34922 PyThreadState* __tstate = wxPyBeginAllowThreads();
34923 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 {
34928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34929 }
34930 return resultobj;
34931 fail:
34932 return NULL;
34933 }
34934
34935
34936 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34937 PyObject *resultobj = 0;
34938 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34939 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34940 bool result;
34941 void *argp1 = 0 ;
34942 int res1 = 0 ;
34943 void *argp2 = 0 ;
34944 int res2 = 0 ;
34945 PyObject * obj0 = 0 ;
34946 PyObject * obj1 = 0 ;
34947 char * kwnames[] = {
34948 (char *) "self",(char *) "other", NULL
34949 };
34950
34951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34953 if (!SWIG_IsOK(res1)) {
34954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34955 }
34956 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34957 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34958 if (!SWIG_IsOK(res2)) {
34959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34960 }
34961 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 {
34969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34970 }
34971 return resultobj;
34972 fail:
34973 return NULL;
34974 }
34975
34976
34977 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34978 PyObject *resultobj = 0;
34979 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34980 int arg2 ;
34981 void *argp1 = 0 ;
34982 int res1 = 0 ;
34983 int val2 ;
34984 int ecode2 = 0 ;
34985 PyObject *swig_obj[2] ;
34986
34987 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34989 if (!SWIG_IsOK(res1)) {
34990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34991 }
34992 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34993 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34994 if (!SWIG_IsOK(ecode2)) {
34995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34996 }
34997 arg2 = static_cast< int >(val2);
34998 if (arg1) (arg1)->w = arg2;
34999
35000 resultobj = SWIG_Py_Void();
35001 return resultobj;
35002 fail:
35003 return NULL;
35004 }
35005
35006
35007 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35008 PyObject *resultobj = 0;
35009 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35010 int result;
35011 void *argp1 = 0 ;
35012 int res1 = 0 ;
35013 PyObject *swig_obj[1] ;
35014
35015 if (!args) SWIG_fail;
35016 swig_obj[0] = args;
35017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35018 if (!SWIG_IsOK(res1)) {
35019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35020 }
35021 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35022 result = (int) ((arg1)->w);
35023 resultobj = SWIG_From_int(static_cast< int >(result));
35024 return resultobj;
35025 fail:
35026 return NULL;
35027 }
35028
35029
35030 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35031 PyObject *resultobj = 0;
35032 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35033 int arg2 ;
35034 void *argp1 = 0 ;
35035 int res1 = 0 ;
35036 int val2 ;
35037 int ecode2 = 0 ;
35038 PyObject *swig_obj[2] ;
35039
35040 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
35041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35042 if (!SWIG_IsOK(res1)) {
35043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35044 }
35045 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35046 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35047 if (!SWIG_IsOK(ecode2)) {
35048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
35049 }
35050 arg2 = static_cast< int >(val2);
35051 if (arg1) (arg1)->h = arg2;
35052
35053 resultobj = SWIG_Py_Void();
35054 return resultobj;
35055 fail:
35056 return NULL;
35057 }
35058
35059
35060 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35061 PyObject *resultobj = 0;
35062 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35063 int result;
35064 void *argp1 = 0 ;
35065 int res1 = 0 ;
35066 PyObject *swig_obj[1] ;
35067
35068 if (!args) SWIG_fail;
35069 swig_obj[0] = args;
35070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35071 if (!SWIG_IsOK(res1)) {
35072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35073 }
35074 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35075 result = (int) ((arg1)->h);
35076 resultobj = SWIG_From_int(static_cast< int >(result));
35077 return resultobj;
35078 fail:
35079 return NULL;
35080 }
35081
35082
35083 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35084 PyObject *resultobj = 0;
35085 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35086 int arg2 ;
35087 void *argp1 = 0 ;
35088 int res1 = 0 ;
35089 int val2 ;
35090 int ecode2 = 0 ;
35091 PyObject *swig_obj[2] ;
35092
35093 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
35094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35095 if (!SWIG_IsOK(res1)) {
35096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35097 }
35098 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35099 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35100 if (!SWIG_IsOK(ecode2)) {
35101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
35102 }
35103 arg2 = static_cast< int >(val2);
35104 if (arg1) (arg1)->bpp = arg2;
35105
35106 resultobj = SWIG_Py_Void();
35107 return resultobj;
35108 fail:
35109 return NULL;
35110 }
35111
35112
35113 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35114 PyObject *resultobj = 0;
35115 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35116 int result;
35117 void *argp1 = 0 ;
35118 int res1 = 0 ;
35119 PyObject *swig_obj[1] ;
35120
35121 if (!args) SWIG_fail;
35122 swig_obj[0] = args;
35123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35124 if (!SWIG_IsOK(res1)) {
35125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35126 }
35127 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35128 result = (int) ((arg1)->bpp);
35129 resultobj = SWIG_From_int(static_cast< int >(result));
35130 return resultobj;
35131 fail:
35132 return NULL;
35133 }
35134
35135
35136 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35137 PyObject *resultobj = 0;
35138 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35139 int arg2 ;
35140 void *argp1 = 0 ;
35141 int res1 = 0 ;
35142 int val2 ;
35143 int ecode2 = 0 ;
35144 PyObject *swig_obj[2] ;
35145
35146 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
35147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35148 if (!SWIG_IsOK(res1)) {
35149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35150 }
35151 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35152 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
35153 if (!SWIG_IsOK(ecode2)) {
35154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
35155 }
35156 arg2 = static_cast< int >(val2);
35157 if (arg1) (arg1)->refresh = arg2;
35158
35159 resultobj = SWIG_Py_Void();
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35167 PyObject *resultobj = 0;
35168 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
35169 int result;
35170 void *argp1 = 0 ;
35171 int res1 = 0 ;
35172 PyObject *swig_obj[1] ;
35173
35174 if (!args) SWIG_fail;
35175 swig_obj[0] = args;
35176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
35177 if (!SWIG_IsOK(res1)) {
35178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
35179 }
35180 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
35181 result = (int) ((arg1)->refresh);
35182 resultobj = SWIG_From_int(static_cast< int >(result));
35183 return resultobj;
35184 fail:
35185 return NULL;
35186 }
35187
35188
35189 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35190 PyObject *obj;
35191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35192 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
35193 return SWIG_Py_Void();
35194 }
35195
35196 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35197 return SWIG_Python_InitShadowInstance(args);
35198 }
35199
35200 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
35201 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
35202 return 1;
35203 }
35204
35205
35206 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
35207 PyObject *pyobj = 0;
35208
35209 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
35210 return pyobj;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35215 PyObject *resultobj = 0;
35216 size_t arg1 = (size_t) 0 ;
35217 wxDisplay *result = 0 ;
35218 size_t val1 ;
35219 int ecode1 = 0 ;
35220 PyObject * obj0 = 0 ;
35221 char * kwnames[] = {
35222 (char *) "index", NULL
35223 };
35224
35225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35226 if (obj0) {
35227 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35228 if (!SWIG_IsOK(ecode1)) {
35229 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35230 }
35231 arg1 = static_cast< size_t >(val1);
35232 }
35233 {
35234 PyThreadState* __tstate = wxPyBeginAllowThreads();
35235 result = (wxDisplay *)new wxDisplay(arg1);
35236 wxPyEndAllowThreads(__tstate);
35237 if (PyErr_Occurred()) SWIG_fail;
35238 }
35239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35240 return resultobj;
35241 fail:
35242 return NULL;
35243 }
35244
35245
35246 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35247 PyObject *resultobj = 0;
35248 wxDisplay *arg1 = (wxDisplay *) 0 ;
35249 void *argp1 = 0 ;
35250 int res1 = 0 ;
35251 PyObject *swig_obj[1] ;
35252
35253 if (!args) SWIG_fail;
35254 swig_obj[0] = args;
35255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35256 if (!SWIG_IsOK(res1)) {
35257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35258 }
35259 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35260 {
35261 PyThreadState* __tstate = wxPyBeginAllowThreads();
35262 delete arg1;
35263
35264 wxPyEndAllowThreads(__tstate);
35265 if (PyErr_Occurred()) SWIG_fail;
35266 }
35267 resultobj = SWIG_Py_Void();
35268 return resultobj;
35269 fail:
35270 return NULL;
35271 }
35272
35273
35274 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35275 PyObject *resultobj = 0;
35276 size_t result;
35277
35278 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 result = (size_t)wxDisplay::GetCount();
35282 wxPyEndAllowThreads(__tstate);
35283 if (PyErr_Occurred()) SWIG_fail;
35284 }
35285 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35286 return resultobj;
35287 fail:
35288 return NULL;
35289 }
35290
35291
35292 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35293 PyObject *resultobj = 0;
35294 wxPoint *arg1 = 0 ;
35295 int result;
35296 wxPoint temp1 ;
35297 PyObject * obj0 = 0 ;
35298 char * kwnames[] = {
35299 (char *) "pt", NULL
35300 };
35301
35302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35303 {
35304 arg1 = &temp1;
35305 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35306 }
35307 {
35308 PyThreadState* __tstate = wxPyBeginAllowThreads();
35309 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35310 wxPyEndAllowThreads(__tstate);
35311 if (PyErr_Occurred()) SWIG_fail;
35312 }
35313 resultobj = SWIG_From_int(static_cast< int >(result));
35314 return resultobj;
35315 fail:
35316 return NULL;
35317 }
35318
35319
35320 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35321 PyObject *resultobj = 0;
35322 wxWindow *arg1 = (wxWindow *) 0 ;
35323 int result;
35324 void *argp1 = 0 ;
35325 int res1 = 0 ;
35326 PyObject * obj0 = 0 ;
35327 char * kwnames[] = {
35328 (char *) "window", NULL
35329 };
35330
35331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35333 if (!SWIG_IsOK(res1)) {
35334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35335 }
35336 arg1 = reinterpret_cast< wxWindow * >(argp1);
35337 {
35338 PyThreadState* __tstate = wxPyBeginAllowThreads();
35339 result = (int)wxDisplay::GetFromWindow(arg1);
35340 wxPyEndAllowThreads(__tstate);
35341 if (PyErr_Occurred()) SWIG_fail;
35342 }
35343 resultobj = SWIG_From_int(static_cast< int >(result));
35344 return resultobj;
35345 fail:
35346 return NULL;
35347 }
35348
35349
35350 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35351 PyObject *resultobj = 0;
35352 wxDisplay *arg1 = (wxDisplay *) 0 ;
35353 bool result;
35354 void *argp1 = 0 ;
35355 int res1 = 0 ;
35356 PyObject *swig_obj[1] ;
35357
35358 if (!args) SWIG_fail;
35359 swig_obj[0] = args;
35360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35361 if (!SWIG_IsOK(res1)) {
35362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35363 }
35364 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35365 {
35366 PyThreadState* __tstate = wxPyBeginAllowThreads();
35367 result = (bool)((wxDisplay const *)arg1)->IsOk();
35368 wxPyEndAllowThreads(__tstate);
35369 if (PyErr_Occurred()) SWIG_fail;
35370 }
35371 {
35372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35373 }
35374 return resultobj;
35375 fail:
35376 return NULL;
35377 }
35378
35379
35380 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35381 PyObject *resultobj = 0;
35382 wxDisplay *arg1 = (wxDisplay *) 0 ;
35383 wxRect result;
35384 void *argp1 = 0 ;
35385 int res1 = 0 ;
35386 PyObject *swig_obj[1] ;
35387
35388 if (!args) SWIG_fail;
35389 swig_obj[0] = args;
35390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35391 if (!SWIG_IsOK(res1)) {
35392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35393 }
35394 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35395 {
35396 PyThreadState* __tstate = wxPyBeginAllowThreads();
35397 result = ((wxDisplay const *)arg1)->GetGeometry();
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 SWIGINTERN PyObject *_wrap_Display_GetClientArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35409 PyObject *resultobj = 0;
35410 wxDisplay *arg1 = (wxDisplay *) 0 ;
35411 wxRect result;
35412 void *argp1 = 0 ;
35413 int res1 = 0 ;
35414 PyObject *swig_obj[1] ;
35415
35416 if (!args) SWIG_fail;
35417 swig_obj[0] = args;
35418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35419 if (!SWIG_IsOK(res1)) {
35420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetClientArea" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35421 }
35422 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35423 {
35424 PyThreadState* __tstate = wxPyBeginAllowThreads();
35425 result = ((wxDisplay const *)arg1)->GetClientArea();
35426 wxPyEndAllowThreads(__tstate);
35427 if (PyErr_Occurred()) SWIG_fail;
35428 }
35429 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35430 return resultobj;
35431 fail:
35432 return NULL;
35433 }
35434
35435
35436 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35437 PyObject *resultobj = 0;
35438 wxDisplay *arg1 = (wxDisplay *) 0 ;
35439 wxString result;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 PyObject *swig_obj[1] ;
35443
35444 if (!args) SWIG_fail;
35445 swig_obj[0] = args;
35446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35449 }
35450 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = ((wxDisplay const *)arg1)->GetName();
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 {
35458 #if wxUSE_UNICODE
35459 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35460 #else
35461 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35462 #endif
35463 }
35464 return resultobj;
35465 fail:
35466 return NULL;
35467 }
35468
35469
35470 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35471 PyObject *resultobj = 0;
35472 wxDisplay *arg1 = (wxDisplay *) 0 ;
35473 bool result;
35474 void *argp1 = 0 ;
35475 int res1 = 0 ;
35476 PyObject *swig_obj[1] ;
35477
35478 if (!args) SWIG_fail;
35479 swig_obj[0] = args;
35480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35481 if (!SWIG_IsOK(res1)) {
35482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35483 }
35484 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35485 {
35486 PyThreadState* __tstate = wxPyBeginAllowThreads();
35487 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35488 wxPyEndAllowThreads(__tstate);
35489 if (PyErr_Occurred()) SWIG_fail;
35490 }
35491 {
35492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35493 }
35494 return resultobj;
35495 fail:
35496 return NULL;
35497 }
35498
35499
35500 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35501 PyObject *resultobj = 0;
35502 wxDisplay *arg1 = (wxDisplay *) 0 ;
35503 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35504 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35505 PyObject *result = 0 ;
35506 void *argp1 = 0 ;
35507 int res1 = 0 ;
35508 void *argp2 = 0 ;
35509 int res2 = 0 ;
35510 PyObject * obj0 = 0 ;
35511 PyObject * obj1 = 0 ;
35512 char * kwnames[] = {
35513 (char *) "self",(char *) "mode", NULL
35514 };
35515
35516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35518 if (!SWIG_IsOK(res1)) {
35519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35520 }
35521 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35522 if (obj1) {
35523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35524 if (!SWIG_IsOK(res2)) {
35525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35526 }
35527 if (!argp2) {
35528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35529 }
35530 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35531 }
35532 {
35533 PyThreadState* __tstate = wxPyBeginAllowThreads();
35534 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35535 wxPyEndAllowThreads(__tstate);
35536 if (PyErr_Occurred()) SWIG_fail;
35537 }
35538 resultobj = result;
35539 return resultobj;
35540 fail:
35541 return NULL;
35542 }
35543
35544
35545 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35546 PyObject *resultobj = 0;
35547 wxDisplay *arg1 = (wxDisplay *) 0 ;
35548 wxVideoMode result;
35549 void *argp1 = 0 ;
35550 int res1 = 0 ;
35551 PyObject *swig_obj[1] ;
35552
35553 if (!args) SWIG_fail;
35554 swig_obj[0] = args;
35555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35556 if (!SWIG_IsOK(res1)) {
35557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35558 }
35559 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35560 {
35561 PyThreadState* __tstate = wxPyBeginAllowThreads();
35562 result = wxDisplay_GetCurrentMode((wxDisplay const *)arg1);
35563 wxPyEndAllowThreads(__tstate);
35564 if (PyErr_Occurred()) SWIG_fail;
35565 }
35566 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35567 return resultobj;
35568 fail:
35569 return NULL;
35570 }
35571
35572
35573 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35574 PyObject *resultobj = 0;
35575 wxDisplay *arg1 = (wxDisplay *) 0 ;
35576 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35577 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35578 bool result;
35579 void *argp1 = 0 ;
35580 int res1 = 0 ;
35581 void *argp2 = 0 ;
35582 int res2 = 0 ;
35583 PyObject * obj0 = 0 ;
35584 PyObject * obj1 = 0 ;
35585 char * kwnames[] = {
35586 (char *) "self",(char *) "mode", NULL
35587 };
35588
35589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35591 if (!SWIG_IsOK(res1)) {
35592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35593 }
35594 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35595 if (obj1) {
35596 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35597 if (!SWIG_IsOK(res2)) {
35598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35599 }
35600 if (!argp2) {
35601 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35602 }
35603 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35604 }
35605 {
35606 PyThreadState* __tstate = wxPyBeginAllowThreads();
35607 result = (bool)wxDisplay_ChangeMode(arg1,(wxVideoMode const &)*arg2);
35608 wxPyEndAllowThreads(__tstate);
35609 if (PyErr_Occurred()) SWIG_fail;
35610 }
35611 {
35612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35613 }
35614 return resultobj;
35615 fail:
35616 return NULL;
35617 }
35618
35619
35620 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35621 PyObject *resultobj = 0;
35622 wxDisplay *arg1 = (wxDisplay *) 0 ;
35623 void *argp1 = 0 ;
35624 int res1 = 0 ;
35625 PyObject *swig_obj[1] ;
35626
35627 if (!args) SWIG_fail;
35628 swig_obj[0] = args;
35629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35630 if (!SWIG_IsOK(res1)) {
35631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35632 }
35633 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35634 {
35635 PyThreadState* __tstate = wxPyBeginAllowThreads();
35636 wxDisplay_ResetMode(arg1);
35637 wxPyEndAllowThreads(__tstate);
35638 if (PyErr_Occurred()) SWIG_fail;
35639 }
35640 resultobj = SWIG_Py_Void();
35641 return resultobj;
35642 fail:
35643 return NULL;
35644 }
35645
35646
35647 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35648 PyObject *obj;
35649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35650 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35651 return SWIG_Py_Void();
35652 }
35653
35654 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35655 return SWIG_Python_InitShadowInstance(args);
35656 }
35657
35658 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35659 PyObject *resultobj = 0;
35660 wxStandardPaths *result = 0 ;
35661
35662 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35663 {
35664 PyThreadState* __tstate = wxPyBeginAllowThreads();
35665 result = (wxStandardPaths *)wxStandardPaths_Get();
35666 wxPyEndAllowThreads(__tstate);
35667 if (PyErr_Occurred()) SWIG_fail;
35668 }
35669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35670 return resultobj;
35671 fail:
35672 return NULL;
35673 }
35674
35675
35676 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35677 PyObject *resultobj = 0;
35678 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35679 wxString result;
35680 void *argp1 = 0 ;
35681 int res1 = 0 ;
35682 PyObject *swig_obj[1] ;
35683
35684 if (!args) SWIG_fail;
35685 swig_obj[0] = args;
35686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35687 if (!SWIG_IsOK(res1)) {
35688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35689 }
35690 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35691 {
35692 PyThreadState* __tstate = wxPyBeginAllowThreads();
35693 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35694 wxPyEndAllowThreads(__tstate);
35695 if (PyErr_Occurred()) SWIG_fail;
35696 }
35697 {
35698 #if wxUSE_UNICODE
35699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35700 #else
35701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35702 #endif
35703 }
35704 return resultobj;
35705 fail:
35706 return NULL;
35707 }
35708
35709
35710 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35711 PyObject *resultobj = 0;
35712 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35713 wxString result;
35714 void *argp1 = 0 ;
35715 int res1 = 0 ;
35716 PyObject *swig_obj[1] ;
35717
35718 if (!args) SWIG_fail;
35719 swig_obj[0] = args;
35720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35721 if (!SWIG_IsOK(res1)) {
35722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35723 }
35724 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35725 {
35726 PyThreadState* __tstate = wxPyBeginAllowThreads();
35727 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35728 wxPyEndAllowThreads(__tstate);
35729 if (PyErr_Occurred()) SWIG_fail;
35730 }
35731 {
35732 #if wxUSE_UNICODE
35733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35734 #else
35735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35736 #endif
35737 }
35738 return resultobj;
35739 fail:
35740 return NULL;
35741 }
35742
35743
35744 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35745 PyObject *resultobj = 0;
35746 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35747 wxString result;
35748 void *argp1 = 0 ;
35749 int res1 = 0 ;
35750 PyObject *swig_obj[1] ;
35751
35752 if (!args) SWIG_fail;
35753 swig_obj[0] = args;
35754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35755 if (!SWIG_IsOK(res1)) {
35756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35757 }
35758 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35759 {
35760 PyThreadState* __tstate = wxPyBeginAllowThreads();
35761 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35762 wxPyEndAllowThreads(__tstate);
35763 if (PyErr_Occurred()) SWIG_fail;
35764 }
35765 {
35766 #if wxUSE_UNICODE
35767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35768 #else
35769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35770 #endif
35771 }
35772 return resultobj;
35773 fail:
35774 return NULL;
35775 }
35776
35777
35778 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35779 PyObject *resultobj = 0;
35780 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35781 wxString result;
35782 void *argp1 = 0 ;
35783 int res1 = 0 ;
35784 PyObject *swig_obj[1] ;
35785
35786 if (!args) SWIG_fail;
35787 swig_obj[0] = args;
35788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35789 if (!SWIG_IsOK(res1)) {
35790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35791 }
35792 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 {
35800 #if wxUSE_UNICODE
35801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35802 #else
35803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35804 #endif
35805 }
35806 return resultobj;
35807 fail:
35808 return NULL;
35809 }
35810
35811
35812 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35813 PyObject *resultobj = 0;
35814 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35815 wxString result;
35816 void *argp1 = 0 ;
35817 int res1 = 0 ;
35818 PyObject *swig_obj[1] ;
35819
35820 if (!args) SWIG_fail;
35821 swig_obj[0] = args;
35822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35823 if (!SWIG_IsOK(res1)) {
35824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35825 }
35826 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35827 {
35828 PyThreadState* __tstate = wxPyBeginAllowThreads();
35829 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35830 wxPyEndAllowThreads(__tstate);
35831 if (PyErr_Occurred()) SWIG_fail;
35832 }
35833 {
35834 #if wxUSE_UNICODE
35835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35836 #else
35837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35838 #endif
35839 }
35840 return resultobj;
35841 fail:
35842 return NULL;
35843 }
35844
35845
35846 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35847 PyObject *resultobj = 0;
35848 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35849 wxString result;
35850 void *argp1 = 0 ;
35851 int res1 = 0 ;
35852 PyObject *swig_obj[1] ;
35853
35854 if (!args) SWIG_fail;
35855 swig_obj[0] = args;
35856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35859 }
35860 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35861 {
35862 PyThreadState* __tstate = wxPyBeginAllowThreads();
35863 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35864 wxPyEndAllowThreads(__tstate);
35865 if (PyErr_Occurred()) SWIG_fail;
35866 }
35867 {
35868 #if wxUSE_UNICODE
35869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35870 #else
35871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35872 #endif
35873 }
35874 return resultobj;
35875 fail:
35876 return NULL;
35877 }
35878
35879
35880 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35881 PyObject *resultobj = 0;
35882 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35883 wxString result;
35884 void *argp1 = 0 ;
35885 int res1 = 0 ;
35886 PyObject *swig_obj[1] ;
35887
35888 if (!args) SWIG_fail;
35889 swig_obj[0] = args;
35890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35891 if (!SWIG_IsOK(res1)) {
35892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35893 }
35894 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35895 {
35896 PyThreadState* __tstate = wxPyBeginAllowThreads();
35897 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35898 wxPyEndAllowThreads(__tstate);
35899 if (PyErr_Occurred()) SWIG_fail;
35900 }
35901 {
35902 #if wxUSE_UNICODE
35903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35904 #else
35905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35906 #endif
35907 }
35908 return resultobj;
35909 fail:
35910 return NULL;
35911 }
35912
35913
35914 SWIGINTERN PyObject *_wrap_StandardPaths_GetResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35915 PyObject *resultobj = 0;
35916 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35917 wxString result;
35918 void *argp1 = 0 ;
35919 int res1 = 0 ;
35920 PyObject *swig_obj[1] ;
35921
35922 if (!args) SWIG_fail;
35923 swig_obj[0] = args;
35924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35925 if (!SWIG_IsOK(res1)) {
35926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35927 }
35928 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35929 {
35930 PyThreadState* __tstate = wxPyBeginAllowThreads();
35931 result = ((wxStandardPaths const *)arg1)->GetResourcesDir();
35932 wxPyEndAllowThreads(__tstate);
35933 if (PyErr_Occurred()) SWIG_fail;
35934 }
35935 {
35936 #if wxUSE_UNICODE
35937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35938 #else
35939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35940 #endif
35941 }
35942 return resultobj;
35943 fail:
35944 return NULL;
35945 }
35946
35947
35948 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalizedResourcesDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35949 PyObject *resultobj = 0;
35950 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35951 wxString *arg2 = 0 ;
35952 wxStandardPaths::ResourceCat arg3 = (wxStandardPaths::ResourceCat) wxStandardPaths::ResourceCat_None ;
35953 wxString result;
35954 void *argp1 = 0 ;
35955 int res1 = 0 ;
35956 bool temp2 = false ;
35957 int val3 ;
35958 int ecode3 = 0 ;
35959 PyObject * obj0 = 0 ;
35960 PyObject * obj1 = 0 ;
35961 PyObject * obj2 = 0 ;
35962 char * kwnames[] = {
35963 (char *) "self",(char *) "lang",(char *) "category", NULL
35964 };
35965
35966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:StandardPaths_GetLocalizedResourcesDir",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35968 if (!SWIG_IsOK(res1)) {
35969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35970 }
35971 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35972 {
35973 arg2 = wxString_in_helper(obj1);
35974 if (arg2 == NULL) SWIG_fail;
35975 temp2 = true;
35976 }
35977 if (obj2) {
35978 ecode3 = SWIG_AsVal_int(obj2, &val3);
35979 if (!SWIG_IsOK(ecode3)) {
35980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StandardPaths_GetLocalizedResourcesDir" "', expected argument " "3"" of type '" "wxStandardPaths::ResourceCat""'");
35981 }
35982 arg3 = static_cast< wxStandardPaths::ResourceCat >(val3);
35983 }
35984 {
35985 PyThreadState* __tstate = wxPyBeginAllowThreads();
35986 result = ((wxStandardPaths const *)arg1)->GetLocalizedResourcesDir((wxString const &)*arg2,arg3);
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 {
35991 #if wxUSE_UNICODE
35992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35993 #else
35994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35995 #endif
35996 }
35997 {
35998 if (temp2)
35999 delete arg2;
36000 }
36001 return resultobj;
36002 fail:
36003 {
36004 if (temp2)
36005 delete arg2;
36006 }
36007 return NULL;
36008 }
36009
36010
36011 SWIGINTERN PyObject *_wrap_StandardPaths_GetDocumentsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36012 PyObject *resultobj = 0;
36013 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36014 wxString result;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017 PyObject *swig_obj[1] ;
36018
36019 if (!args) SWIG_fail;
36020 swig_obj[0] = args;
36021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36022 if (!SWIG_IsOK(res1)) {
36023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDocumentsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36024 }
36025 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36026 {
36027 PyThreadState* __tstate = wxPyBeginAllowThreads();
36028 result = ((wxStandardPaths const *)arg1)->GetDocumentsDir();
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 {
36033 #if wxUSE_UNICODE
36034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36035 #else
36036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36037 #endif
36038 }
36039 return resultobj;
36040 fail:
36041 return NULL;
36042 }
36043
36044
36045 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36046 PyObject *resultobj = 0;
36047 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36048 wxString *arg2 = 0 ;
36049 void *argp1 = 0 ;
36050 int res1 = 0 ;
36051 bool temp2 = false ;
36052 PyObject * obj0 = 0 ;
36053 PyObject * obj1 = 0 ;
36054 char * kwnames[] = {
36055 (char *) "self",(char *) "prefix", NULL
36056 };
36057
36058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
36059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36060 if (!SWIG_IsOK(res1)) {
36061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
36062 }
36063 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36064 {
36065 arg2 = wxString_in_helper(obj1);
36066 if (arg2 == NULL) SWIG_fail;
36067 temp2 = true;
36068 }
36069 {
36070 PyThreadState* __tstate = wxPyBeginAllowThreads();
36071 (arg1)->SetInstallPrefix((wxString const &)*arg2);
36072 wxPyEndAllowThreads(__tstate);
36073 if (PyErr_Occurred()) SWIG_fail;
36074 }
36075 resultobj = SWIG_Py_Void();
36076 {
36077 if (temp2)
36078 delete arg2;
36079 }
36080 return resultobj;
36081 fail:
36082 {
36083 if (temp2)
36084 delete arg2;
36085 }
36086 return NULL;
36087 }
36088
36089
36090 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36091 PyObject *resultobj = 0;
36092 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
36093 wxString result;
36094 void *argp1 = 0 ;
36095 int res1 = 0 ;
36096 PyObject *swig_obj[1] ;
36097
36098 if (!args) SWIG_fail;
36099 swig_obj[0] = args;
36100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
36101 if (!SWIG_IsOK(res1)) {
36102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
36103 }
36104 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 {
36112 #if wxUSE_UNICODE
36113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36114 #else
36115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36116 #endif
36117 }
36118 return resultobj;
36119 fail:
36120 return NULL;
36121 }
36122
36123
36124 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36125 PyObject *obj;
36126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36127 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
36128 return SWIG_Py_Void();
36129 }
36130
36131 SWIGINTERN PyObject *_wrap_new_PowerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36132 PyObject *resultobj = 0;
36133 wxEventType arg1 ;
36134 wxPowerEvent *result = 0 ;
36135 int val1 ;
36136 int ecode1 = 0 ;
36137 PyObject * obj0 = 0 ;
36138 char * kwnames[] = {
36139 (char *) "evtType", NULL
36140 };
36141
36142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PowerEvent",kwnames,&obj0)) SWIG_fail;
36143 ecode1 = SWIG_AsVal_int(obj0, &val1);
36144 if (!SWIG_IsOK(ecode1)) {
36145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PowerEvent" "', expected argument " "1"" of type '" "wxEventType""'");
36146 }
36147 arg1 = static_cast< wxEventType >(val1);
36148 {
36149 PyThreadState* __tstate = wxPyBeginAllowThreads();
36150 result = (wxPowerEvent *)new wxPowerEvent(arg1);
36151 wxPyEndAllowThreads(__tstate);
36152 if (PyErr_Occurred()) SWIG_fail;
36153 }
36154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPowerEvent, SWIG_POINTER_NEW | 0 );
36155 return resultobj;
36156 fail:
36157 return NULL;
36158 }
36159
36160
36161 SWIGINTERN PyObject *_wrap_PowerEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36162 PyObject *resultobj = 0;
36163 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36164 void *argp1 = 0 ;
36165 int res1 = 0 ;
36166 PyObject *swig_obj[1] ;
36167
36168 if (!args) SWIG_fail;
36169 swig_obj[0] = args;
36170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36171 if (!SWIG_IsOK(res1)) {
36172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_Veto" "', expected argument " "1"" of type '" "wxPowerEvent *""'");
36173 }
36174 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36175 {
36176 PyThreadState* __tstate = wxPyBeginAllowThreads();
36177 (arg1)->Veto();
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 resultobj = SWIG_Py_Void();
36182 return resultobj;
36183 fail:
36184 return NULL;
36185 }
36186
36187
36188 SWIGINTERN PyObject *_wrap_PowerEvent_IsVetoed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36189 PyObject *resultobj = 0;
36190 wxPowerEvent *arg1 = (wxPowerEvent *) 0 ;
36191 bool result;
36192 void *argp1 = 0 ;
36193 int res1 = 0 ;
36194 PyObject *swig_obj[1] ;
36195
36196 if (!args) SWIG_fail;
36197 swig_obj[0] = args;
36198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPowerEvent, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerEvent_IsVetoed" "', expected argument " "1"" of type '" "wxPowerEvent const *""'");
36201 }
36202 arg1 = reinterpret_cast< wxPowerEvent * >(argp1);
36203 {
36204 PyThreadState* __tstate = wxPyBeginAllowThreads();
36205 result = (bool)((wxPowerEvent const *)arg1)->IsVetoed();
36206 wxPyEndAllowThreads(__tstate);
36207 if (PyErr_Occurred()) SWIG_fail;
36208 }
36209 {
36210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36211 }
36212 return resultobj;
36213 fail:
36214 return NULL;
36215 }
36216
36217
36218 SWIGINTERN PyObject *PowerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36219 PyObject *obj;
36220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
36221 SWIG_TypeNewClientData(SWIGTYPE_p_wxPowerEvent, SWIG_NewClientData(obj));
36222 return SWIG_Py_Void();
36223 }
36224
36225 SWIGINTERN PyObject *PowerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36226 return SWIG_Python_InitShadowInstance(args);
36227 }
36228
36229 SWIGINTERN PyObject *_wrap_GetPowerType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36230 PyObject *resultobj = 0;
36231 wxPowerType result;
36232
36233 if (!SWIG_Python_UnpackTuple(args,"GetPowerType",0,0,0)) SWIG_fail;
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 result = (wxPowerType)wxGetPowerType();
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 resultobj = SWIG_From_int(static_cast< int >(result));
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_GetBatteryState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36248 PyObject *resultobj = 0;
36249 wxBatteryState result;
36250
36251 if (!SWIG_Python_UnpackTuple(args,"GetBatteryState",0,0,0)) SWIG_fail;
36252 {
36253 PyThreadState* __tstate = wxPyBeginAllowThreads();
36254 result = (wxBatteryState)wxGetBatteryState();
36255 wxPyEndAllowThreads(__tstate);
36256 if (PyErr_Occurred()) SWIG_fail;
36257 }
36258 resultobj = SWIG_From_int(static_cast< int >(result));
36259 return resultobj;
36260 fail:
36261 return NULL;
36262 }
36263
36264
36265 static PyMethodDef SwigMethods[] = {
36266 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
36267 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
36268 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
36270 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
36271 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
36272 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
36273 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
36274 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36275 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36276 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
36277 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
36280 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
36281 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
36282 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
36283 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
36285 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
36289 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
36290 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
36291 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
36292 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
36293 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
36294 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
36295 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
36296 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
36297 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
36298 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
36302 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
36304 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
36305 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
36306 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
36307 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
36308 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
36309 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
36310 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
36312 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
36313 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
36317 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
36324 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
36325 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
36326 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
36327 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
36328 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
36329 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
36330 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
36331 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
36332 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
36334 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36335 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
36336 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
36337 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
36338 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
36343 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
36344 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
36345 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
36346 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
36347 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
36348 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
36349 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
36350 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
36351 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
36352 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
36353 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
36354 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
36355 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
36357 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36358 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
36365 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
36366 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
36367 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
36368 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
36369 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
36370 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
36371 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
36372 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
36373 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
36374 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
36375 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
36377 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
36378 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
36379 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
36380 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
36383 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
36384 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
36386 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
36387 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
36388 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
36389 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
36390 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
36391 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
36392 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
36393 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
36394 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
36395 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
36396 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
36397 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
36398 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36399 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
36400 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
36401 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
36402 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
36403 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
36404 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
36406 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
36407 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
36408 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
36410 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
36411 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
36412 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36413 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
36414 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
36415 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
36416 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
36417 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
36419 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
36420 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
36421 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
36422 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
36423 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
36425 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36426 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
36428 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36430 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
36431 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
36432 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
36433 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
36434 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
36436 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
36437 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
36438 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
36439 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
36440 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
36441 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
36443 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
36444 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
36445 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
36446 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
36447 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
36448 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
36449 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
36450 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
36451 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36452 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36453 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
36454 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
36455 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
36458 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
36459 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36460 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
36461 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
36462 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36463 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
36464 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
36465 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
36466 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
36467 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
36468 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
36469 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
36470 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
36471 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
36473 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
36474 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
36475 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
36476 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
36477 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
36478 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
36479 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
36480 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
36481 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
36482 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
36483 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
36486 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
36487 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
36488 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
36490 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
36491 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
36493 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
36494 { (char *)"Log_SetRepetitionCounting", (PyCFunction) _wrap_Log_SetRepetitionCounting, METH_VARARGS | METH_KEYWORDS, NULL},
36495 { (char *)"Log_GetRepetitionCounting", (PyCFunction)_wrap_Log_GetRepetitionCounting, METH_NOARGS, NULL},
36496 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
36500 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
36501 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
36502 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
36503 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
36504 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
36505 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
36506 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36507 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36508 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36509 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36510 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36511 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36512 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36513 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36514 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36515 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36516 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36517 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36518 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36519 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36520 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36521 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36522 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36523 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36524 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36525 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36526 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36527 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36528 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36529 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36531 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36532 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36533 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36534 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36535 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36536 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36537 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36538 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36539 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36540 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36541 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36542 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36543 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36544 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36546 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36547 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36548 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36549 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36550 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36551 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36553 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36554 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36555 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36556 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36557 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36558 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36559 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36561 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36562 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36563 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36565 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36569 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36570 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36571 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36572 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36573 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36574 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36575 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36576 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36577 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36578 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36579 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36580 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36582 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36583 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36584 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36585 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36586 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36587 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36588 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36589 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36590 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36593 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36594 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36595 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36596 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36597 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36598 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36599 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36600 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36601 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36602 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36603 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36604 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36605 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36606 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36607 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36608 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36609 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36610 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36611 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36612 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36613 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36614 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36615 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36616 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36617 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36618 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36619 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36620 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36621 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36622 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36623 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36624 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36625 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36626 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36627 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36628 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36629 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36630 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36631 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36632 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36633 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36634 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36635 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36636 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36637 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36638 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36639 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36640 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36641 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36642 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36643 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36645 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36646 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36649 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36650 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36651 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36652 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36654 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36655 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36656 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36657 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36658 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36659 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36660 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36661 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36662 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36663 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36664 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36665 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36666 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36667 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36668 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36669 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36670 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36671 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36672 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36673 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36674 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36675 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36676 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36677 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36678 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36679 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36680 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36681 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36682 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36683 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36684 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36685 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36686 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36687 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36688 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36689 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36690 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36691 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36692 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36693 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36694 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36695 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36696 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36697 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36698 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36699 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36700 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36701 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36702 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36703 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36704 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36705 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36706 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36707 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36708 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36709 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36710 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36711 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36712 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36713 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36714 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36715 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36716 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36717 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36718 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36719 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36720 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36721 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36722 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36723 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36724 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36725 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36726 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36727 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36728 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36729 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36730 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36731 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36732 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36733 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36734 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36735 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36736 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36737 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36738 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36739 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36740 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36741 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36742 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36743 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36744 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36745 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36746 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36747 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36748 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36749 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36750 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36751 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36752 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36753 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36754 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36755 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36756 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36757 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36758 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36759 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36760 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36761 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36762 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36763 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36764 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36765 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36766 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36767 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36768 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36769 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36770 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36771 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36772 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36773 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36774 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36775 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36776 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36777 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36778 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36779 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36780 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36781 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36782 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36783 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36784 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36785 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36786 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36787 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36788 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36789 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36790 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36791 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36792 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36793 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36794 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36795 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36796 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36797 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36798 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36799 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36800 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36801 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36802 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36803 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36804 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36805 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36806 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36807 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36808 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36809 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36810 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36811 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36812 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36813 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36814 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36815 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36816 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36817 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36818 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36819 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36820 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36821 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36822 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36823 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36824 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36825 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36826 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36827 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36828 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36829 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36830 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36831 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36832 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36833 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36834 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36835 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36836 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36837 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36838 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36839 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36840 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36841 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36842 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36843 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36844 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36845 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36846 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36847 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36848 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36849 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36850 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36851 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36852 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36853 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36854 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36855 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36856 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36857 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36858 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36859 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36860 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36861 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36862 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36863 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36864 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36865 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36866 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36867 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36868 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36869 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36870 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36871 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36872 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36873 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36874 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36875 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36876 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36877 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36878 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36879 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36880 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36881 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36882 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36883 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36884 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36885 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36886 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36887 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36888 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36889 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36890 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36891 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36892 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36893 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36894 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36895 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36896 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36897 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36898 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36899 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36900 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36901 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36902 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36903 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36904 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36905 { (char *)"TimeSpan_Milliseconds", (PyCFunction) _wrap_TimeSpan_Milliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
36906 { (char *)"TimeSpan_Millisecond", (PyCFunction)_wrap_TimeSpan_Millisecond, METH_NOARGS, NULL},
36907 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36908 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36909 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36910 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36911 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36912 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36913 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36914 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36915 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36916 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36917 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36918 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36919 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36920 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36921 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36922 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36923 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36924 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36925 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36926 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36927 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36928 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36929 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36930 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36931 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36932 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36933 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36934 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36935 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36936 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36937 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36938 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36939 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36940 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36941 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36942 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36943 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36944 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36945 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36946 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36947 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36948 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36949 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36950 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36951 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36952 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36953 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36954 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36955 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36956 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36957 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36958 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36959 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36960 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36961 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36962 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36963 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36964 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36965 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36966 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36967 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36968 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36969 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36970 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36971 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36972 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36973 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36974 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36975 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36976 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36977 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36978 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36979 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36980 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36981 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36982 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36983 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36984 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36985 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36986 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36987 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36988 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36989 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36990 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36991 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36992 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36993 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36994 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36995 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36996 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36997 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36998 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36999 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
37000 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
37001 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
37002 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
37003 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
37004 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37005 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
37006 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37007 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
37008 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
37009 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
37010 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37011 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
37012 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37013 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
37014 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
37015 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
37016 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
37017 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37018 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
37019 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
37020 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
37021 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37022 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
37023 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
37024 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
37025 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
37026 { (char *)"DataObjectComposite_GetReceivedFormat", (PyCFunction)_wrap_DataObjectComposite_GetReceivedFormat, METH_O, NULL},
37027 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
37028 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
37029 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37030 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
37031 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
37032 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
37033 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
37034 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
37035 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37036 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37037 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
37038 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
37039 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37040 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
37041 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
37042 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
37043 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
37044 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37045 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37046 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
37047 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
37048 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
37049 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
37050 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
37051 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
37052 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
37053 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
37054 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37055 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
37056 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
37057 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
37058 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
37059 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
37060 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
37061 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
37062 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
37063 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
37064 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
37065 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
37066 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
37067 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
37068 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
37069 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37070 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
37071 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37072 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
37073 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
37074 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37075 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
37076 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
37077 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
37078 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
37079 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37080 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
37081 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
37082 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
37083 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37084 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37085 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
37086 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37087 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
37088 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
37089 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
37090 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
37091 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
37092 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
37093 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37094 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
37095 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37096 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37097 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
37098 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37099 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37100 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
37101 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
37102 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
37103 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
37104 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
37105 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
37106 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
37107 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
37108 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
37109 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
37110 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
37111 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
37112 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
37113 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
37114 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
37115 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
37116 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
37117 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
37118 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
37119 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
37120 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
37121 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
37122 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
37123 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
37124 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
37125 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
37126 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
37127 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
37128 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
37129 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
37130 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
37131 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
37132 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
37133 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
37134 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
37135 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
37136 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
37137 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
37138 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
37139 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
37140 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
37141 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
37142 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
37143 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
37144 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
37145 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
37146 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
37147 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
37148 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
37149 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
37150 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
37151 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
37152 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
37153 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
37154 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
37155 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
37156 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
37157 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
37158 { (char *)"Display_GetClientArea", (PyCFunction)_wrap_Display_GetClientArea, METH_O, NULL},
37159 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
37160 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
37161 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
37162 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
37163 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
37164 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
37165 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
37166 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
37167 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
37168 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
37169 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
37170 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
37171 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
37172 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
37173 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
37174 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
37175 { (char *)"StandardPaths_GetResourcesDir", (PyCFunction)_wrap_StandardPaths_GetResourcesDir, METH_O, NULL},
37176 { (char *)"StandardPaths_GetLocalizedResourcesDir", (PyCFunction) _wrap_StandardPaths_GetLocalizedResourcesDir, METH_VARARGS | METH_KEYWORDS, NULL},
37177 { (char *)"StandardPaths_GetDocumentsDir", (PyCFunction)_wrap_StandardPaths_GetDocumentsDir, METH_O, NULL},
37178 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
37179 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
37180 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
37181 { (char *)"new_PowerEvent", (PyCFunction) _wrap_new_PowerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
37182 { (char *)"PowerEvent_Veto", (PyCFunction)_wrap_PowerEvent_Veto, METH_O, NULL},
37183 { (char *)"PowerEvent_IsVetoed", (PyCFunction)_wrap_PowerEvent_IsVetoed, METH_O, NULL},
37184 { (char *)"PowerEvent_swigregister", PowerEvent_swigregister, METH_VARARGS, NULL},
37185 { (char *)"PowerEvent_swiginit", PowerEvent_swiginit, METH_VARARGS, NULL},
37186 { (char *)"GetPowerType", (PyCFunction)_wrap_GetPowerType, METH_NOARGS, NULL},
37187 { (char *)"GetBatteryState", (PyCFunction)_wrap_GetBatteryState, METH_NOARGS, NULL},
37188 { NULL, NULL, 0, NULL }
37189 };
37190
37191
37192 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
37193
37194 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
37195 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
37196 }
37197 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
37198 return (void *)((wxEvent *) ((wxMenuEvent *) x));
37199 }
37200 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
37201 return (void *)((wxEvent *) ((wxCloseEvent *) x));
37202 }
37203 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
37204 return (void *)((wxEvent *) ((wxMouseEvent *) x));
37205 }
37206 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
37207 return (void *)((wxEvent *) ((wxEraseEvent *) x));
37208 }
37209 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
37210 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
37211 }
37212 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
37213 return (void *)((wxEvent *) ((wxTimerEvent *) x));
37214 }
37215 static void *_p_wxPowerEventTo_p_wxEvent(void *x) {
37216 return (void *)((wxEvent *) ((wxPowerEvent *) x));
37217 }
37218 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
37219 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
37220 }
37221 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
37222 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
37223 }
37224 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
37225 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
37226 }
37227 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
37228 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
37229 }
37230 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
37231 return (void *)((wxEvent *) ((wxPyEvent *) x));
37232 }
37233 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
37234 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
37235 }
37236 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
37237 return (void *)((wxEvent *) ((wxIdleEvent *) x));
37238 }
37239 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
37240 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
37241 }
37242 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
37243 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
37244 }
37245 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
37246 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
37247 }
37248 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
37249 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
37250 }
37251 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
37252 return (void *)((wxEvent *) ((wxActivateEvent *) x));
37253 }
37254 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
37255 return (void *)((wxEvent *) ((wxSizeEvent *) x));
37256 }
37257 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
37258 return (void *)((wxEvent *) ((wxMoveEvent *) x));
37259 }
37260 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
37261 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
37262 }
37263 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
37264 return (void *)((wxEvent *) ((wxPaintEvent *) x));
37265 }
37266 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
37267 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
37268 }
37269 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
37270 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
37271 }
37272 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
37273 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
37274 }
37275 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
37276 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
37277 }
37278 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
37279 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
37280 }
37281 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
37282 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37283 }
37284 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
37285 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
37286 }
37287 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
37288 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
37289 }
37290 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
37291 return (void *)((wxEvent *) ((wxFocusEvent *) x));
37292 }
37293 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
37294 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
37295 }
37296 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
37297 return (void *)((wxEvent *) ((wxProcessEvent *) x));
37298 }
37299 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
37300 return (void *)((wxEvent *) ((wxShowEvent *) x));
37301 }
37302 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
37303 return (void *)((wxEvent *) ((wxCommandEvent *) x));
37304 }
37305 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
37306 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
37307 }
37308 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
37309 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37310 }
37311 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
37312 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
37313 }
37314 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
37315 return (void *)((wxEvent *) ((wxKeyEvent *) x));
37316 }
37317 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
37318 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
37319 }
37320 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
37321 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
37322 }
37323 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
37324 return (void *)((wxConfigBase *) ((wxConfig *) x));
37325 }
37326 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
37327 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37328 }
37329 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
37330 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
37331 }
37332 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
37333 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
37334 }
37335 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
37336 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37337 }
37338 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
37339 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
37340 }
37341 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
37342 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
37343 }
37344 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
37345 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
37346 }
37347 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
37348 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37349 }
37350 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
37351 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37352 }
37353 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
37354 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
37355 }
37356 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
37357 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
37358 }
37359 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
37360 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
37361 }
37362 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
37363 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37364 }
37365 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
37366 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
37367 }
37368 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37369 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
37370 }
37371 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
37372 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
37373 }
37374 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37375 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
37376 }
37377 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
37378 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
37379 }
37380 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
37381 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
37382 }
37383 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
37384 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
37385 }
37386 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
37387 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
37388 }
37389 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
37390 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
37391 }
37392 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
37393 return (void *)((wxEvtHandler *) ((wxWindow *) x));
37394 }
37395 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
37396 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37397 }
37398 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
37399 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
37400 }
37401 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
37402 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
37403 }
37404 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
37405 return (void *)((wxEvtHandler *) ((wxValidator *) x));
37406 }
37407 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
37408 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
37409 }
37410 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
37411 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
37412 }
37413 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
37414 return (void *)((wxEvtHandler *) ((wxMenu *) x));
37415 }
37416 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
37417 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
37418 }
37419 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
37420 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
37421 }
37422 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
37423 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
37424 }
37425 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
37426 return (void *)((wxObject *) ((wxSizerItem *) x));
37427 }
37428 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
37429 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
37430 }
37431 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
37432 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
37433 }
37434 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
37435 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
37436 }
37437 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
37438 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
37439 }
37440 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
37441 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
37442 }
37443 static void *_p_wxSizerTo_p_wxObject(void *x) {
37444 return (void *)((wxObject *) ((wxSizer *) x));
37445 }
37446 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
37447 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
37448 }
37449 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
37450 return (void *)((wxObject *) ((wxFileHistory *) x));
37451 }
37452 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
37453 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
37454 }
37455 static void *_p_wxEventTo_p_wxObject(void *x) {
37456 return (void *)((wxObject *) ((wxEvent *) x));
37457 }
37458 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
37459 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
37460 }
37461 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
37462 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
37463 }
37464 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
37465 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
37466 }
37467 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
37468 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
37469 }
37470 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
37471 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
37472 }
37473 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
37474 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
37475 }
37476 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
37477 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
37478 }
37479 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
37480 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
37481 }
37482 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
37483 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
37484 }
37485 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
37486 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
37487 }
37488 static void *_p_wxControlTo_p_wxObject(void *x) {
37489 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
37490 }
37491 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
37492 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
37493 }
37494 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
37495 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
37496 }
37497 static void *_p_wxPowerEventTo_p_wxObject(void *x) {
37498 return (void *)((wxObject *) (wxEvent *) ((wxPowerEvent *) x));
37499 }
37500 static void *_p_wxFSFileTo_p_wxObject(void *x) {
37501 return (void *)((wxObject *) ((wxFSFile *) x));
37502 }
37503 static void *_p_wxClipboardTo_p_wxObject(void *x) {
37504 return (void *)((wxObject *) ((wxClipboard *) x));
37505 }
37506 static void *_p_wxPySizerTo_p_wxObject(void *x) {
37507 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
37508 }
37509 static void *_p_wxPyEventTo_p_wxObject(void *x) {
37510 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
37511 }
37512 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
37513 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
37514 }
37515 static void *_p_wxShowEventTo_p_wxObject(void *x) {
37516 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
37517 }
37518 static void *_p_wxToolTipTo_p_wxObject(void *x) {
37519 return (void *)((wxObject *) ((wxToolTip *) x));
37520 }
37521 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
37522 return (void *)((wxObject *) ((wxMenuItem *) x));
37523 }
37524 static void *_p_wxDateEventTo_p_wxObject(void *x) {
37525 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
37526 }
37527 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
37528 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
37529 }
37530 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
37531 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
37532 }
37533 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37534 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37535 }
37536 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37537 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37538 }
37539 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37540 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37541 }
37542 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37543 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37544 }
37545 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37546 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37547 }
37548 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37549 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37550 }
37551 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37552 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37553 }
37554 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37555 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37556 }
37557 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37558 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37559 }
37560 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37561 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37562 }
37563 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37564 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37565 }
37566 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37567 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37568 }
37569 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37570 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37571 }
37572 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37573 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37574 }
37575 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37576 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37577 }
37578 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37579 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37580 }
37581 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37582 return (void *)((wxObject *) ((wxImageHandler *) x));
37583 }
37584 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37585 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37586 }
37587 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37588 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37589 }
37590 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37591 return (void *)((wxObject *) ((wxEvtHandler *) x));
37592 }
37593 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
37594 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
37595 }
37596 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37597 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37598 }
37599 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37600 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37601 }
37602 static void *_p_wxImageTo_p_wxObject(void *x) {
37603 return (void *)((wxObject *) ((wxImage *) x));
37604 }
37605 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37606 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37607 }
37608 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37609 return (void *)((wxObject *) ((wxSystemOptions *) x));
37610 }
37611 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37612 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37613 }
37614 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37615 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37616 }
37617 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37618 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37619 }
37620 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37621 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37622 }
37623 static void *_p_wxWindowTo_p_wxObject(void *x) {
37624 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37625 }
37626 static void *_p_wxMenuTo_p_wxObject(void *x) {
37627 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37628 }
37629 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37630 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37631 }
37632 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37633 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37634 }
37635 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37636 return (void *)((wxObject *) ((wxFileSystem *) x));
37637 }
37638 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37639 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37640 }
37641 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37642 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37643 }
37644 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37645 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37646 }
37647 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37648 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37649 }
37650 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37651 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37652 }
37653 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37654 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37655 }
37656 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37657 return (void *)((wxObject *) ((wxBusyInfo *) x));
37658 }
37659 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37660 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37661 }
37662 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37663 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37664 }
37665 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37666 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37667 }
37668 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37669 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37670 }
37671 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37672 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37673 }
37674 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37675 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37676 }
37677 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37678 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37679 }
37680 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37681 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37682 }
37683 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37684 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37685 }
37686 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37687 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37688 }
37689 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37690 return (void *)((wxLog *) ((wxLogBuffer *) x));
37691 }
37692 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37693 return (void *)((wxLog *) ((wxLogStderr *) x));
37694 }
37695 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37696 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37697 }
37698 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37699 return (void *)((wxLog *) ((wxLogWindow *) x));
37700 }
37701 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37702 return (void *)((wxLog *) ((wxLogChain *) x));
37703 }
37704 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37705 return (void *)((wxLog *) ((wxLogGui *) x));
37706 }
37707 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37708 return (void *)((wxLog *) ((wxPyLog *) x));
37709 }
37710 static void *_p_wxControlTo_p_wxWindow(void *x) {
37711 return (void *)((wxWindow *) ((wxControl *) x));
37712 }
37713 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37714 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37715 }
37716 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37717 return (void *)((wxWindow *) ((wxMenuBar *) x));
37718 }
37719 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37720 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37721 }
37722 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37723 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37724 }
37725 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37726 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};
37727 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37728 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37729 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37730 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37731 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37732 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37733 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37734 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37735 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37736 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37737 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37738 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37739 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37740 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37741 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37742 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37743 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37744 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37745 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37746 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37747 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37748 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37749 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37750 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37751 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37752 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37753 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37754 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37755 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37756 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37757 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37758 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37759 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37760 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37761 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37762 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37763 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37764 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37765 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37766 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37767 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37768 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};
37769 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37770 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37771 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37772 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37773 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37774 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37775 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37776 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37777 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37778 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37779 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37780 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};
37781 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37782 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37783 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37784 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37785 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37786 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37787 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37788 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37789 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37790 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37791 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37792 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37793 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37794 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37795 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37796 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37797 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37798 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37799 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37800 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37801 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37802 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37803 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37804 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37805 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37806 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37807 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37808 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37809 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37810 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37811 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37812 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37813 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37814 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37815 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37816 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37817 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37818 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37819 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37820 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37821 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37822 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37823 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37824 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37825 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37826 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37827 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37828 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37829 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37830 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37831 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37832 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37833 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37834 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37835 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37836 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37837 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37838 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37839 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37840 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37841 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37842 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37843 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37844 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37845 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37846 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37847 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37848 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37849 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37850 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37851 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37852 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37853 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37854 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37855 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37856 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37857 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37858 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37859 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37860 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37861 static swig_type_info _swigt__p_wxPowerEvent = {"_p_wxPowerEvent", "wxPowerEvent *", 0, 0, (void*)0, 0};
37862 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37863 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37864 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37865 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37866 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37867 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37868 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37869 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37870 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37871 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37872 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37873 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37874 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37875 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37876 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37877 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37878 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37879 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37880 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37881 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37882 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37883 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37884 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37885 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37886 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37887 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37888 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37889 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37890 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37891 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37892 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37893 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37894 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37895 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37896
37897 static swig_type_info *swig_type_initial[] = {
37898 &_swigt__p_char,
37899 &_swigt__p_form_ops_t,
37900 &_swigt__p_int,
37901 &_swigt__p_unsigned_char,
37902 &_swigt__p_unsigned_int,
37903 &_swigt__p_unsigned_long,
37904 &_swigt__p_void,
37905 &_swigt__p_wxANIHandler,
37906 &_swigt__p_wxAcceleratorTable,
37907 &_swigt__p_wxActivateEvent,
37908 &_swigt__p_wxArrayString,
37909 &_swigt__p_wxBMPHandler,
37910 &_swigt__p_wxBitmap,
37911 &_swigt__p_wxBitmapDataObject,
37912 &_swigt__p_wxBoxSizer,
37913 &_swigt__p_wxBusyCursor,
37914 &_swigt__p_wxBusyInfo,
37915 &_swigt__p_wxCURHandler,
37916 &_swigt__p_wxCaret,
37917 &_swigt__p_wxChar,
37918 &_swigt__p_wxChildFocusEvent,
37919 &_swigt__p_wxClipboard,
37920 &_swigt__p_wxClipboardLocker,
37921 &_swigt__p_wxClipboardTextEvent,
37922 &_swigt__p_wxCloseEvent,
37923 &_swigt__p_wxColour,
37924 &_swigt__p_wxCommandEvent,
37925 &_swigt__p_wxConfig,
37926 &_swigt__p_wxConfigBase,
37927 &_swigt__p_wxConfigPathChanger,
37928 &_swigt__p_wxContextMenuEvent,
37929 &_swigt__p_wxControl,
37930 &_swigt__p_wxControlWithItems,
37931 &_swigt__p_wxCursor,
37932 &_swigt__p_wxCustomDataObject,
37933 &_swigt__p_wxDC,
37934 &_swigt__p_wxDataFormat,
37935 &_swigt__p_wxDataObject,
37936 &_swigt__p_wxDataObjectComposite,
37937 &_swigt__p_wxDataObjectSimple,
37938 &_swigt__p_wxDateEvent,
37939 &_swigt__p_wxDateSpan,
37940 &_swigt__p_wxDateTime,
37941 &_swigt__p_wxDateTime__TimeZone,
37942 &_swigt__p_wxDisplay,
37943 &_swigt__p_wxDisplayChangedEvent,
37944 &_swigt__p_wxDropFilesEvent,
37945 &_swigt__p_wxDuplexMode,
37946 &_swigt__p_wxEraseEvent,
37947 &_swigt__p_wxEvent,
37948 &_swigt__p_wxEvtHandler,
37949 &_swigt__p_wxFSFile,
37950 &_swigt__p_wxFileConfig,
37951 &_swigt__p_wxFileDataObject,
37952 &_swigt__p_wxFileHistory,
37953 &_swigt__p_wxFileSystem,
37954 &_swigt__p_wxFileType,
37955 &_swigt__p_wxFileTypeInfo,
37956 &_swigt__p_wxFlexGridSizer,
37957 &_swigt__p_wxFocusEvent,
37958 &_swigt__p_wxFont,
37959 &_swigt__p_wxFrame,
37960 &_swigt__p_wxGBSizerItem,
37961 &_swigt__p_wxGIFHandler,
37962 &_swigt__p_wxGridBagSizer,
37963 &_swigt__p_wxGridSizer,
37964 &_swigt__p_wxICOHandler,
37965 &_swigt__p_wxIcon,
37966 &_swigt__p_wxIconizeEvent,
37967 &_swigt__p_wxIdleEvent,
37968 &_swigt__p_wxImage,
37969 &_swigt__p_wxImageHandler,
37970 &_swigt__p_wxIndividualLayoutConstraint,
37971 &_swigt__p_wxInitDialogEvent,
37972 &_swigt__p_wxJPEGHandler,
37973 &_swigt__p_wxJoystick,
37974 &_swigt__p_wxJoystickEvent,
37975 &_swigt__p_wxKeyEvent,
37976 &_swigt__p_wxKillError,
37977 &_swigt__p_wxLayoutConstraints,
37978 &_swigt__p_wxLog,
37979 &_swigt__p_wxLogBuffer,
37980 &_swigt__p_wxLogChain,
37981 &_swigt__p_wxLogGui,
37982 &_swigt__p_wxLogNull,
37983 &_swigt__p_wxLogStderr,
37984 &_swigt__p_wxLogTextCtrl,
37985 &_swigt__p_wxLogWindow,
37986 &_swigt__p_wxMaximizeEvent,
37987 &_swigt__p_wxMenu,
37988 &_swigt__p_wxMenuBar,
37989 &_swigt__p_wxMenuEvent,
37990 &_swigt__p_wxMenuItem,
37991 &_swigt__p_wxMetafileDataObject,
37992 &_swigt__p_wxMimeTypesManager,
37993 &_swigt__p_wxMouseCaptureChangedEvent,
37994 &_swigt__p_wxMouseCaptureLostEvent,
37995 &_swigt__p_wxMouseEvent,
37996 &_swigt__p_wxMouseState,
37997 &_swigt__p_wxMoveEvent,
37998 &_swigt__p_wxMutexGuiLocker,
37999 &_swigt__p_wxNavigationKeyEvent,
38000 &_swigt__p_wxNcPaintEvent,
38001 &_swigt__p_wxNotifyEvent,
38002 &_swigt__p_wxObject,
38003 &_swigt__p_wxOutputStream,
38004 &_swigt__p_wxPCXHandler,
38005 &_swigt__p_wxPNGHandler,
38006 &_swigt__p_wxPNMHandler,
38007 &_swigt__p_wxPaintEvent,
38008 &_swigt__p_wxPaletteChangedEvent,
38009 &_swigt__p_wxPaperSize,
38010 &_swigt__p_wxPoint,
38011 &_swigt__p_wxPowerEvent,
38012 &_swigt__p_wxProcessEvent,
38013 &_swigt__p_wxPyApp,
38014 &_swigt__p_wxPyArtProvider,
38015 &_swigt__p_wxPyBitmapDataObject,
38016 &_swigt__p_wxPyCommandEvent,
38017 &_swigt__p_wxPyDataObjectSimple,
38018 &_swigt__p_wxPyDropSource,
38019 &_swigt__p_wxPyDropTarget,
38020 &_swigt__p_wxPyEvent,
38021 &_swigt__p_wxPyFileDropTarget,
38022 &_swigt__p_wxPyImageHandler,
38023 &_swigt__p_wxPyLog,
38024 &_swigt__p_wxPyProcess,
38025 &_swigt__p_wxPySizer,
38026 &_swigt__p_wxPyTextDataObject,
38027 &_swigt__p_wxPyTextDropTarget,
38028 &_swigt__p_wxPyTimer,
38029 &_swigt__p_wxPyTipProvider,
38030 &_swigt__p_wxPyValidator,
38031 &_swigt__p_wxQueryNewPaletteEvent,
38032 &_swigt__p_wxRect,
38033 &_swigt__p_wxScrollEvent,
38034 &_swigt__p_wxScrollWinEvent,
38035 &_swigt__p_wxSetCursorEvent,
38036 &_swigt__p_wxShowEvent,
38037 &_swigt__p_wxSingleInstanceChecker,
38038 &_swigt__p_wxSize,
38039 &_swigt__p_wxSizeEvent,
38040 &_swigt__p_wxSizer,
38041 &_swigt__p_wxSizerItem,
38042 &_swigt__p_wxSound,
38043 &_swigt__p_wxStandardPaths,
38044 &_swigt__p_wxStaticBoxSizer,
38045 &_swigt__p_wxStdDialogButtonSizer,
38046 &_swigt__p_wxStopWatch,
38047 &_swigt__p_wxString,
38048 &_swigt__p_wxSysColourChangedEvent,
38049 &_swigt__p_wxSystemOptions,
38050 &_swigt__p_wxSystemSettings,
38051 &_swigt__p_wxTIFFHandler,
38052 &_swigt__p_wxTextCtrl,
38053 &_swigt__p_wxTextDataObject,
38054 &_swigt__p_wxTimeSpan,
38055 &_swigt__p_wxTimer,
38056 &_swigt__p_wxTimerEvent,
38057 &_swigt__p_wxTimerRunner,
38058 &_swigt__p_wxTipProvider,
38059 &_swigt__p_wxToolTip,
38060 &_swigt__p_wxURLDataObject,
38061 &_swigt__p_wxUpdateUIEvent,
38062 &_swigt__p_wxValidator,
38063 &_swigt__p_wxVideoMode,
38064 &_swigt__p_wxWindow,
38065 &_swigt__p_wxWindowCreateEvent,
38066 &_swigt__p_wxWindowDestroyEvent,
38067 &_swigt__p_wxWindowDisabler,
38068 &_swigt__p_wxXPMHandler,
38069 };
38070
38071 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
38072 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
38073 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
38074 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
38075 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
38076 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
38077 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
38078 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
38079 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
38080 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}};
38081 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
38082 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
38083 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
38084 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
38085 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
38086 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
38087 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
38088 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
38089 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}};
38090 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
38091 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
38092 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
38093 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
38094 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
38095 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}};
38096 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
38097 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}};
38098 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
38099 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
38100 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
38101 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
38102 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
38103 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38104 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
38105 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
38106 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
38107 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
38108 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
38109 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
38110 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
38111 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
38112 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
38113 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
38114 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
38115 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
38116 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
38117 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38118 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38119 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
38120 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
38121 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
38122 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
38123 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38124 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
38125 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
38126 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
38127 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38128 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38129 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38130 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
38131 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
38132 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38133 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
38134 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
38135 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38136 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
38137 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
38138 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38139 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
38140 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
38141 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}};
38142 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
38143 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
38144 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
38145 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
38146 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
38147 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
38148 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}};
38149 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
38150 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38151 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
38152 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
38153 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
38154 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
38155 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
38156 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
38157 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
38158 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
38159 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
38160 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}};
38161 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
38162 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
38163 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
38164 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
38165 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
38166 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38167 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
38168 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
38169 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
38170 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
38171 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
38172 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
38173 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
38174 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38175 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
38176 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
38177 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38178 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
38179 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
38180 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
38181 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38182 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
38183 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
38184 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
38185 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
38186 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38187 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
38188 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
38189 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
38190 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
38191 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
38192 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
38193 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
38194 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
38195 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
38196 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
38197 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
38198 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
38199 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
38200 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
38201 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
38202 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
38203 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileHistory, _p_wxFileHistoryTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTimerEvent, _p_wxTimerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPowerEvent, _p_wxPowerEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboard, _p_wxClipboardTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxToolTip, _p_wxToolTipTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSystemOptions, _p_wxSystemOptionsTo_p_wxObject, 0, 0}, {&_swigt__p_wxJoystickEvent, _p_wxJoystickEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyProcess, _p_wxPyProcessTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxBusyInfo, _p_wxBusyInfoTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTimer, _p_wxPyTimerTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
38204 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
38205 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
38206 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
38207 static swig_cast_info _swigc__p_wxPowerEvent[] = { {&_swigt__p_wxPowerEvent, 0, 0, 0},{0, 0, 0, 0}};
38208 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
38209 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
38210 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
38211 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
38212 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
38213 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}};
38214 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38215 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
38216 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
38217 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
38218 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
38219 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
38220 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
38221 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
38222 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
38223 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
38224 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
38225 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
38226 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
38227 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
38228 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
38229 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
38230 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
38231 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}};
38232 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
38233 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
38234 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
38235 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
38236 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}};
38237 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
38238 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
38239 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
38240 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}};
38241 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
38242
38243 static swig_cast_info *swig_cast_initial[] = {
38244 _swigc__p_char,
38245 _swigc__p_form_ops_t,
38246 _swigc__p_int,
38247 _swigc__p_unsigned_char,
38248 _swigc__p_unsigned_int,
38249 _swigc__p_unsigned_long,
38250 _swigc__p_void,
38251 _swigc__p_wxANIHandler,
38252 _swigc__p_wxAcceleratorTable,
38253 _swigc__p_wxActivateEvent,
38254 _swigc__p_wxArrayString,
38255 _swigc__p_wxBMPHandler,
38256 _swigc__p_wxBitmap,
38257 _swigc__p_wxBitmapDataObject,
38258 _swigc__p_wxBoxSizer,
38259 _swigc__p_wxBusyCursor,
38260 _swigc__p_wxBusyInfo,
38261 _swigc__p_wxCURHandler,
38262 _swigc__p_wxCaret,
38263 _swigc__p_wxChar,
38264 _swigc__p_wxChildFocusEvent,
38265 _swigc__p_wxClipboard,
38266 _swigc__p_wxClipboardLocker,
38267 _swigc__p_wxClipboardTextEvent,
38268 _swigc__p_wxCloseEvent,
38269 _swigc__p_wxColour,
38270 _swigc__p_wxCommandEvent,
38271 _swigc__p_wxConfig,
38272 _swigc__p_wxConfigBase,
38273 _swigc__p_wxConfigPathChanger,
38274 _swigc__p_wxContextMenuEvent,
38275 _swigc__p_wxControl,
38276 _swigc__p_wxControlWithItems,
38277 _swigc__p_wxCursor,
38278 _swigc__p_wxCustomDataObject,
38279 _swigc__p_wxDC,
38280 _swigc__p_wxDataFormat,
38281 _swigc__p_wxDataObject,
38282 _swigc__p_wxDataObjectComposite,
38283 _swigc__p_wxDataObjectSimple,
38284 _swigc__p_wxDateEvent,
38285 _swigc__p_wxDateSpan,
38286 _swigc__p_wxDateTime,
38287 _swigc__p_wxDateTime__TimeZone,
38288 _swigc__p_wxDisplay,
38289 _swigc__p_wxDisplayChangedEvent,
38290 _swigc__p_wxDropFilesEvent,
38291 _swigc__p_wxDuplexMode,
38292 _swigc__p_wxEraseEvent,
38293 _swigc__p_wxEvent,
38294 _swigc__p_wxEvtHandler,
38295 _swigc__p_wxFSFile,
38296 _swigc__p_wxFileConfig,
38297 _swigc__p_wxFileDataObject,
38298 _swigc__p_wxFileHistory,
38299 _swigc__p_wxFileSystem,
38300 _swigc__p_wxFileType,
38301 _swigc__p_wxFileTypeInfo,
38302 _swigc__p_wxFlexGridSizer,
38303 _swigc__p_wxFocusEvent,
38304 _swigc__p_wxFont,
38305 _swigc__p_wxFrame,
38306 _swigc__p_wxGBSizerItem,
38307 _swigc__p_wxGIFHandler,
38308 _swigc__p_wxGridBagSizer,
38309 _swigc__p_wxGridSizer,
38310 _swigc__p_wxICOHandler,
38311 _swigc__p_wxIcon,
38312 _swigc__p_wxIconizeEvent,
38313 _swigc__p_wxIdleEvent,
38314 _swigc__p_wxImage,
38315 _swigc__p_wxImageHandler,
38316 _swigc__p_wxIndividualLayoutConstraint,
38317 _swigc__p_wxInitDialogEvent,
38318 _swigc__p_wxJPEGHandler,
38319 _swigc__p_wxJoystick,
38320 _swigc__p_wxJoystickEvent,
38321 _swigc__p_wxKeyEvent,
38322 _swigc__p_wxKillError,
38323 _swigc__p_wxLayoutConstraints,
38324 _swigc__p_wxLog,
38325 _swigc__p_wxLogBuffer,
38326 _swigc__p_wxLogChain,
38327 _swigc__p_wxLogGui,
38328 _swigc__p_wxLogNull,
38329 _swigc__p_wxLogStderr,
38330 _swigc__p_wxLogTextCtrl,
38331 _swigc__p_wxLogWindow,
38332 _swigc__p_wxMaximizeEvent,
38333 _swigc__p_wxMenu,
38334 _swigc__p_wxMenuBar,
38335 _swigc__p_wxMenuEvent,
38336 _swigc__p_wxMenuItem,
38337 _swigc__p_wxMetafileDataObject,
38338 _swigc__p_wxMimeTypesManager,
38339 _swigc__p_wxMouseCaptureChangedEvent,
38340 _swigc__p_wxMouseCaptureLostEvent,
38341 _swigc__p_wxMouseEvent,
38342 _swigc__p_wxMouseState,
38343 _swigc__p_wxMoveEvent,
38344 _swigc__p_wxMutexGuiLocker,
38345 _swigc__p_wxNavigationKeyEvent,
38346 _swigc__p_wxNcPaintEvent,
38347 _swigc__p_wxNotifyEvent,
38348 _swigc__p_wxObject,
38349 _swigc__p_wxOutputStream,
38350 _swigc__p_wxPCXHandler,
38351 _swigc__p_wxPNGHandler,
38352 _swigc__p_wxPNMHandler,
38353 _swigc__p_wxPaintEvent,
38354 _swigc__p_wxPaletteChangedEvent,
38355 _swigc__p_wxPaperSize,
38356 _swigc__p_wxPoint,
38357 _swigc__p_wxPowerEvent,
38358 _swigc__p_wxProcessEvent,
38359 _swigc__p_wxPyApp,
38360 _swigc__p_wxPyArtProvider,
38361 _swigc__p_wxPyBitmapDataObject,
38362 _swigc__p_wxPyCommandEvent,
38363 _swigc__p_wxPyDataObjectSimple,
38364 _swigc__p_wxPyDropSource,
38365 _swigc__p_wxPyDropTarget,
38366 _swigc__p_wxPyEvent,
38367 _swigc__p_wxPyFileDropTarget,
38368 _swigc__p_wxPyImageHandler,
38369 _swigc__p_wxPyLog,
38370 _swigc__p_wxPyProcess,
38371 _swigc__p_wxPySizer,
38372 _swigc__p_wxPyTextDataObject,
38373 _swigc__p_wxPyTextDropTarget,
38374 _swigc__p_wxPyTimer,
38375 _swigc__p_wxPyTipProvider,
38376 _swigc__p_wxPyValidator,
38377 _swigc__p_wxQueryNewPaletteEvent,
38378 _swigc__p_wxRect,
38379 _swigc__p_wxScrollEvent,
38380 _swigc__p_wxScrollWinEvent,
38381 _swigc__p_wxSetCursorEvent,
38382 _swigc__p_wxShowEvent,
38383 _swigc__p_wxSingleInstanceChecker,
38384 _swigc__p_wxSize,
38385 _swigc__p_wxSizeEvent,
38386 _swigc__p_wxSizer,
38387 _swigc__p_wxSizerItem,
38388 _swigc__p_wxSound,
38389 _swigc__p_wxStandardPaths,
38390 _swigc__p_wxStaticBoxSizer,
38391 _swigc__p_wxStdDialogButtonSizer,
38392 _swigc__p_wxStopWatch,
38393 _swigc__p_wxString,
38394 _swigc__p_wxSysColourChangedEvent,
38395 _swigc__p_wxSystemOptions,
38396 _swigc__p_wxSystemSettings,
38397 _swigc__p_wxTIFFHandler,
38398 _swigc__p_wxTextCtrl,
38399 _swigc__p_wxTextDataObject,
38400 _swigc__p_wxTimeSpan,
38401 _swigc__p_wxTimer,
38402 _swigc__p_wxTimerEvent,
38403 _swigc__p_wxTimerRunner,
38404 _swigc__p_wxTipProvider,
38405 _swigc__p_wxToolTip,
38406 _swigc__p_wxURLDataObject,
38407 _swigc__p_wxUpdateUIEvent,
38408 _swigc__p_wxValidator,
38409 _swigc__p_wxVideoMode,
38410 _swigc__p_wxWindow,
38411 _swigc__p_wxWindowCreateEvent,
38412 _swigc__p_wxWindowDestroyEvent,
38413 _swigc__p_wxWindowDisabler,
38414 _swigc__p_wxXPMHandler,
38415 };
38416
38417
38418 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
38419
38420 static swig_const_info swig_const_table[] = {
38421 {0, 0, 0, 0.0, 0, 0}};
38422
38423 #ifdef __cplusplus
38424 }
38425 #endif
38426 /* -----------------------------------------------------------------------------
38427 * Type initialization:
38428 * This problem is tough by the requirement that no dynamic
38429 * memory is used. Also, since swig_type_info structures store pointers to
38430 * swig_cast_info structures and swig_cast_info structures store pointers back
38431 * to swig_type_info structures, we need some lookup code at initialization.
38432 * The idea is that swig generates all the structures that are needed.
38433 * The runtime then collects these partially filled structures.
38434 * The SWIG_InitializeModule function takes these initial arrays out of
38435 * swig_module, and does all the lookup, filling in the swig_module.types
38436 * array with the correct data and linking the correct swig_cast_info
38437 * structures together.
38438 *
38439 * The generated swig_type_info structures are assigned staticly to an initial
38440 * array. We just loop though that array, and handle each type individually.
38441 * First we lookup if this type has been already loaded, and if so, use the
38442 * loaded structure instead of the generated one. Then we have to fill in the
38443 * cast linked list. The cast data is initially stored in something like a
38444 * two-dimensional array. Each row corresponds to a type (there are the same
38445 * number of rows as there are in the swig_type_initial array). Each entry in
38446 * a column is one of the swig_cast_info structures for that type.
38447 * The cast_initial array is actually an array of arrays, because each row has
38448 * a variable number of columns. So to actually build the cast linked list,
38449 * we find the array of casts associated with the type, and loop through it
38450 * adding the casts to the list. The one last trick we need to do is making
38451 * sure the type pointer in the swig_cast_info struct is correct.
38452 *
38453 * First off, we lookup the cast->type name to see if it is already loaded.
38454 * There are three cases to handle:
38455 * 1) If the cast->type has already been loaded AND the type we are adding
38456 * casting info to has not been loaded (it is in this module), THEN we
38457 * replace the cast->type pointer with the type pointer that has already
38458 * been loaded.
38459 * 2) If BOTH types (the one we are adding casting info to, and the
38460 * cast->type) are loaded, THEN the cast info has already been loaded by
38461 * the previous module so we just ignore it.
38462 * 3) Finally, if cast->type has not already been loaded, then we add that
38463 * swig_cast_info to the linked list (because the cast->type) pointer will
38464 * be correct.
38465 * ----------------------------------------------------------------------------- */
38466
38467 #ifdef __cplusplus
38468 extern "C" {
38469 #if 0
38470 } /* c-mode */
38471 #endif
38472 #endif
38473
38474 #if 0
38475 #define SWIGRUNTIME_DEBUG
38476 #endif
38477
38478 SWIGRUNTIME void
38479 SWIG_InitializeModule(void *clientdata) {
38480 size_t i;
38481 swig_module_info *module_head;
38482 static int init_run = 0;
38483
38484 clientdata = clientdata;
38485
38486 if (init_run) return;
38487 init_run = 1;
38488
38489 /* Initialize the swig_module */
38490 swig_module.type_initial = swig_type_initial;
38491 swig_module.cast_initial = swig_cast_initial;
38492
38493 /* Try and load any already created modules */
38494 module_head = SWIG_GetModule(clientdata);
38495 if (module_head) {
38496 swig_module.next = module_head->next;
38497 module_head->next = &swig_module;
38498 } else {
38499 /* This is the first module loaded */
38500 swig_module.next = &swig_module;
38501 SWIG_SetModule(clientdata, &swig_module);
38502 }
38503
38504 /* Now work on filling in swig_module.types */
38505 #ifdef SWIGRUNTIME_DEBUG
38506 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
38507 #endif
38508 for (i = 0; i < swig_module.size; ++i) {
38509 swig_type_info *type = 0;
38510 swig_type_info *ret;
38511 swig_cast_info *cast;
38512
38513 #ifdef SWIGRUNTIME_DEBUG
38514 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38515 #endif
38516
38517 /* if there is another module already loaded */
38518 if (swig_module.next != &swig_module) {
38519 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
38520 }
38521 if (type) {
38522 /* Overwrite clientdata field */
38523 #ifdef SWIGRUNTIME_DEBUG
38524 printf("SWIG_InitializeModule: found type %s\n", type->name);
38525 #endif
38526 if (swig_module.type_initial[i]->clientdata) {
38527 type->clientdata = swig_module.type_initial[i]->clientdata;
38528 #ifdef SWIGRUNTIME_DEBUG
38529 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
38530 #endif
38531 }
38532 } else {
38533 type = swig_module.type_initial[i];
38534 }
38535
38536 /* Insert casting types */
38537 cast = swig_module.cast_initial[i];
38538 while (cast->type) {
38539 /* Don't need to add information already in the list */
38540 ret = 0;
38541 #ifdef SWIGRUNTIME_DEBUG
38542 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38543 #endif
38544 if (swig_module.next != &swig_module) {
38545 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38546 #ifdef SWIGRUNTIME_DEBUG
38547 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38548 #endif
38549 }
38550 if (ret) {
38551 if (type == swig_module.type_initial[i]) {
38552 #ifdef SWIGRUNTIME_DEBUG
38553 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38554 #endif
38555 cast->type = ret;
38556 ret = 0;
38557 } else {
38558 /* Check for casting already in the list */
38559 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38560 #ifdef SWIGRUNTIME_DEBUG
38561 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38562 #endif
38563 if (!ocast) ret = 0;
38564 }
38565 }
38566
38567 if (!ret) {
38568 #ifdef SWIGRUNTIME_DEBUG
38569 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38570 #endif
38571 if (type->cast) {
38572 type->cast->prev = cast;
38573 cast->next = type->cast;
38574 }
38575 type->cast = cast;
38576 }
38577 cast++;
38578 }
38579 /* Set entry in modules->types array equal to the type */
38580 swig_module.types[i] = type;
38581 }
38582 swig_module.types[i] = 0;
38583
38584 #ifdef SWIGRUNTIME_DEBUG
38585 printf("**** SWIG_InitializeModule: Cast List ******\n");
38586 for (i = 0; i < swig_module.size; ++i) {
38587 int j = 0;
38588 swig_cast_info *cast = swig_module.cast_initial[i];
38589 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38590 while (cast->type) {
38591 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38592 cast++;
38593 ++j;
38594 }
38595 printf("---- Total casts: %d\n",j);
38596 }
38597 printf("**** SWIG_InitializeModule: Cast List ******\n");
38598 #endif
38599 }
38600
38601 /* This function will propagate the clientdata field of type to
38602 * any new swig_type_info structures that have been added into the list
38603 * of equivalent types. It is like calling
38604 * SWIG_TypeClientData(type, clientdata) a second time.
38605 */
38606 SWIGRUNTIME void
38607 SWIG_PropagateClientData(void) {
38608 size_t i;
38609 swig_cast_info *equiv;
38610 static int init_run = 0;
38611
38612 if (init_run) return;
38613 init_run = 1;
38614
38615 for (i = 0; i < swig_module.size; i++) {
38616 if (swig_module.types[i]->clientdata) {
38617 equiv = swig_module.types[i]->cast;
38618 while (equiv) {
38619 if (!equiv->converter) {
38620 if (equiv->type && !equiv->type->clientdata)
38621 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38622 }
38623 equiv = equiv->next;
38624 }
38625 }
38626 }
38627 }
38628
38629 #ifdef __cplusplus
38630 #if 0
38631 {
38632 /* c-mode */
38633 #endif
38634 }
38635 #endif
38636
38637
38638
38639 #ifdef __cplusplus
38640 extern "C" {
38641 #endif
38642
38643 /* Python-specific SWIG API */
38644 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38645 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38646 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38647
38648 /* -----------------------------------------------------------------------------
38649 * global variable support code.
38650 * ----------------------------------------------------------------------------- */
38651
38652 typedef struct swig_globalvar {
38653 char *name; /* Name of global variable */
38654 PyObject *(*get_attr)(void); /* Return the current value */
38655 int (*set_attr)(PyObject *); /* Set the value */
38656 struct swig_globalvar *next;
38657 } swig_globalvar;
38658
38659 typedef struct swig_varlinkobject {
38660 PyObject_HEAD
38661 swig_globalvar *vars;
38662 } swig_varlinkobject;
38663
38664 SWIGINTERN PyObject *
38665 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38666 return PyString_FromString("<Swig global variables>");
38667 }
38668
38669 SWIGINTERN PyObject *
38670 swig_varlink_str(swig_varlinkobject *v) {
38671 PyObject *str = PyString_FromString("(");
38672 swig_globalvar *var;
38673 for (var = v->vars; var; var=var->next) {
38674 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38675 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38676 }
38677 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38678 return str;
38679 }
38680
38681 SWIGINTERN int
38682 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38683 PyObject *str = swig_varlink_str(v);
38684 fprintf(fp,"Swig global variables ");
38685 fprintf(fp,"%s\n", PyString_AsString(str));
38686 Py_DECREF(str);
38687 return 0;
38688 }
38689
38690 SWIGINTERN void
38691 swig_varlink_dealloc(swig_varlinkobject *v) {
38692 swig_globalvar *var = v->vars;
38693 while (var) {
38694 swig_globalvar *n = var->next;
38695 free(var->name);
38696 free(var);
38697 var = n;
38698 }
38699 }
38700
38701 SWIGINTERN PyObject *
38702 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38703 PyObject *res = NULL;
38704 swig_globalvar *var = v->vars;
38705 while (var) {
38706 if (strcmp(var->name,n) == 0) {
38707 res = (*var->get_attr)();
38708 break;
38709 }
38710 var = var->next;
38711 }
38712 if (res == NULL && !PyErr_Occurred()) {
38713 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38714 }
38715 return res;
38716 }
38717
38718 SWIGINTERN int
38719 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38720 int res = 1;
38721 swig_globalvar *var = v->vars;
38722 while (var) {
38723 if (strcmp(var->name,n) == 0) {
38724 res = (*var->set_attr)(p);
38725 break;
38726 }
38727 var = var->next;
38728 }
38729 if (res == 1 && !PyErr_Occurred()) {
38730 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38731 }
38732 return res;
38733 }
38734
38735 SWIGINTERN PyTypeObject*
38736 swig_varlink_type(void) {
38737 static char varlink__doc__[] = "Swig var link object";
38738 static PyTypeObject varlink_type;
38739 static int type_init = 0;
38740 if (!type_init) {
38741 const PyTypeObject tmp
38742 = {
38743 PyObject_HEAD_INIT(NULL)
38744 0, /* Number of items in variable part (ob_size) */
38745 (char *)"swigvarlink", /* Type name (tp_name) */
38746 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38747 0, /* Itemsize (tp_itemsize) */
38748 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38749 (printfunc) swig_varlink_print, /* Print (tp_print) */
38750 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38751 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38752 0, /* tp_compare */
38753 (reprfunc) swig_varlink_repr, /* tp_repr */
38754 0, /* tp_as_number */
38755 0, /* tp_as_sequence */
38756 0, /* tp_as_mapping */
38757 0, /* tp_hash */
38758 0, /* tp_call */
38759 (reprfunc)swig_varlink_str, /* tp_str */
38760 0, /* tp_getattro */
38761 0, /* tp_setattro */
38762 0, /* tp_as_buffer */
38763 0, /* tp_flags */
38764 varlink__doc__, /* tp_doc */
38765 0, /* tp_traverse */
38766 0, /* tp_clear */
38767 0, /* tp_richcompare */
38768 0, /* tp_weaklistoffset */
38769 #if PY_VERSION_HEX >= 0x02020000
38770 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38771 #endif
38772 #if PY_VERSION_HEX >= 0x02030000
38773 0, /* tp_del */
38774 #endif
38775 #ifdef COUNT_ALLOCS
38776 0,0,0,0 /* tp_alloc -> tp_next */
38777 #endif
38778 };
38779 varlink_type = tmp;
38780 varlink_type.ob_type = &PyType_Type;
38781 type_init = 1;
38782 }
38783 return &varlink_type;
38784 }
38785
38786 /* Create a variable linking object for use later */
38787 SWIGINTERN PyObject *
38788 SWIG_Python_newvarlink(void) {
38789 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38790 if (result) {
38791 result->vars = 0;
38792 }
38793 return ((PyObject*) result);
38794 }
38795
38796 SWIGINTERN void
38797 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38798 swig_varlinkobject *v = (swig_varlinkobject *) p;
38799 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38800 if (gv) {
38801 size_t size = strlen(name)+1;
38802 gv->name = (char *)malloc(size);
38803 if (gv->name) {
38804 strncpy(gv->name,name,size);
38805 gv->get_attr = get_attr;
38806 gv->set_attr = set_attr;
38807 gv->next = v->vars;
38808 }
38809 }
38810 v->vars = gv;
38811 }
38812
38813 SWIGINTERN PyObject *
38814 SWIG_globals() {
38815 static PyObject *_SWIG_globals = 0;
38816 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38817 return _SWIG_globals;
38818 }
38819
38820 /* -----------------------------------------------------------------------------
38821 * constants/methods manipulation
38822 * ----------------------------------------------------------------------------- */
38823
38824 /* Install Constants */
38825 SWIGINTERN void
38826 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38827 PyObject *obj = 0;
38828 size_t i;
38829 for (i = 0; constants[i].type; ++i) {
38830 switch(constants[i].type) {
38831 case SWIG_PY_POINTER:
38832 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38833 break;
38834 case SWIG_PY_BINARY:
38835 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38836 break;
38837 default:
38838 obj = 0;
38839 break;
38840 }
38841 if (obj) {
38842 PyDict_SetItemString(d, constants[i].name, obj);
38843 Py_DECREF(obj);
38844 }
38845 }
38846 }
38847
38848 /* -----------------------------------------------------------------------------*/
38849 /* Fix SwigMethods to carry the callback ptrs when needed */
38850 /* -----------------------------------------------------------------------------*/
38851
38852 SWIGINTERN void
38853 SWIG_Python_FixMethods(PyMethodDef *methods,
38854 swig_const_info *const_table,
38855 swig_type_info **types,
38856 swig_type_info **types_initial) {
38857 size_t i;
38858 for (i = 0; methods[i].ml_name; ++i) {
38859 const char *c = methods[i].ml_doc;
38860 if (c && (c = strstr(c, "swig_ptr: "))) {
38861 int j;
38862 swig_const_info *ci = 0;
38863 const char *name = c + 10;
38864 for (j = 0; const_table[j].type; ++j) {
38865 if (strncmp(const_table[j].name, name,
38866 strlen(const_table[j].name)) == 0) {
38867 ci = &(const_table[j]);
38868 break;
38869 }
38870 }
38871 if (ci) {
38872 size_t shift = (ci->ptype) - types;
38873 swig_type_info *ty = types_initial[shift];
38874 size_t ldoc = (c - methods[i].ml_doc);
38875 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38876 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38877 if (ndoc) {
38878 char *buff = ndoc;
38879 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38880 if (ptr) {
38881 strncpy(buff, methods[i].ml_doc, ldoc);
38882 buff += ldoc;
38883 strncpy(buff, "swig_ptr: ", 10);
38884 buff += 10;
38885 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38886 methods[i].ml_doc = ndoc;
38887 }
38888 }
38889 }
38890 }
38891 }
38892 }
38893
38894 #ifdef __cplusplus
38895 }
38896 #endif
38897
38898 /* -----------------------------------------------------------------------------*
38899 * Partial Init method
38900 * -----------------------------------------------------------------------------*/
38901
38902 #ifdef __cplusplus
38903 extern "C"
38904 #endif
38905 SWIGEXPORT void SWIG_init(void) {
38906 PyObject *m, *d;
38907
38908 /* Fix SwigMethods to carry the callback ptrs when needed */
38909 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38910
38911 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38912 d = PyModule_GetDict(m);
38913
38914 SWIG_InitializeModule(0);
38915 SWIG_InstallConstants(d,swig_const_table);
38916
38917
38918 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38919 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38920 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38921 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38922 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38923 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38924 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38925 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38926 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38927 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38928 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38929 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38930 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38931 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38932 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38933 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38934 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38935 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38936 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38937 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38938 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38939 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38940 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38941 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38942 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38943 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38944 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38945 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38946 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38947 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38948 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38949 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38950 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38951 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38952 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38953 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38954 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38955 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38956 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38957 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38958 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38959 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38960 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38961 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38962 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38963 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38964 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38965 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38966 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38967 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38968 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38969 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38970 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38971 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38972 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38973 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38974 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38975 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38976 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38977 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38978 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38979 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38980 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38981 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38982 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38983 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38984 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38985 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38986 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38987 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38988 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38989 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38990 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38991 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38992 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38993 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38994 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38995 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38996 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38997 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38998 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38999 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
39000 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
39001 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
39002 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
39003 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
39004 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
39005 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
39006 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
39007 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
39008 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
39009 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
39010 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
39011 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
39012 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
39013 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
39014 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
39015 SWIG_Python_SetConstant(d, "UNKNOWN_PLATFORM",SWIG_From_int(static_cast< int >(wxUNKNOWN_PLATFORM)));
39016 SWIG_Python_SetConstant(d, "CURSES",SWIG_From_int(static_cast< int >(wxCURSES)));
39017 SWIG_Python_SetConstant(d, "XVIEW_X",SWIG_From_int(static_cast< int >(wxXVIEW_X)));
39018 SWIG_Python_SetConstant(d, "MOTIF_X",SWIG_From_int(static_cast< int >(wxMOTIF_X)));
39019 SWIG_Python_SetConstant(d, "COSE_X",SWIG_From_int(static_cast< int >(wxCOSE_X)));
39020 SWIG_Python_SetConstant(d, "NEXTSTEP",SWIG_From_int(static_cast< int >(wxNEXTSTEP)));
39021 SWIG_Python_SetConstant(d, "MAC",SWIG_From_int(static_cast< int >(wxMAC)));
39022 SWIG_Python_SetConstant(d, "MAC_DARWIN",SWIG_From_int(static_cast< int >(wxMAC_DARWIN)));
39023 SWIG_Python_SetConstant(d, "BEOS",SWIG_From_int(static_cast< int >(wxBEOS)));
39024 SWIG_Python_SetConstant(d, "GTK",SWIG_From_int(static_cast< int >(wxGTK)));
39025 SWIG_Python_SetConstant(d, "GTK_WIN32",SWIG_From_int(static_cast< int >(wxGTK_WIN32)));
39026 SWIG_Python_SetConstant(d, "GTK_OS2",SWIG_From_int(static_cast< int >(wxGTK_OS2)));
39027 SWIG_Python_SetConstant(d, "GTK_BEOS",SWIG_From_int(static_cast< int >(wxGTK_BEOS)));
39028 SWIG_Python_SetConstant(d, "GEOS",SWIG_From_int(static_cast< int >(wxGEOS)));
39029 SWIG_Python_SetConstant(d, "OS2_PM",SWIG_From_int(static_cast< int >(wxOS2_PM)));
39030 SWIG_Python_SetConstant(d, "WINDOWS",SWIG_From_int(static_cast< int >(wxWINDOWS)));
39031 SWIG_Python_SetConstant(d, "MICROWINDOWS",SWIG_From_int(static_cast< int >(wxMICROWINDOWS)));
39032 SWIG_Python_SetConstant(d, "PENWINDOWS",SWIG_From_int(static_cast< int >(wxPENWINDOWS)));
39033 SWIG_Python_SetConstant(d, "WINDOWS_NT",SWIG_From_int(static_cast< int >(wxWINDOWS_NT)));
39034 SWIG_Python_SetConstant(d, "WIN32S",SWIG_From_int(static_cast< int >(wxWIN32S)));
39035 SWIG_Python_SetConstant(d, "WIN95",SWIG_From_int(static_cast< int >(wxWIN95)));
39036 SWIG_Python_SetConstant(d, "WIN386",SWIG_From_int(static_cast< int >(wxWIN386)));
39037 SWIG_Python_SetConstant(d, "WINDOWS_CE",SWIG_From_int(static_cast< int >(wxWINDOWS_CE)));
39038 SWIG_Python_SetConstant(d, "WINDOWS_POCKETPC",SWIG_From_int(static_cast< int >(wxWINDOWS_POCKETPC)));
39039 SWIG_Python_SetConstant(d, "WINDOWS_SMARTPHONE",SWIG_From_int(static_cast< int >(wxWINDOWS_SMARTPHONE)));
39040 SWIG_Python_SetConstant(d, "MGL_UNIX",SWIG_From_int(static_cast< int >(wxMGL_UNIX)));
39041 SWIG_Python_SetConstant(d, "MGL_X",SWIG_From_int(static_cast< int >(wxMGL_X)));
39042 SWIG_Python_SetConstant(d, "MGL_WIN32",SWIG_From_int(static_cast< int >(wxMGL_WIN32)));
39043 SWIG_Python_SetConstant(d, "MGL_OS2",SWIG_From_int(static_cast< int >(wxMGL_OS2)));
39044 SWIG_Python_SetConstant(d, "MGL_DOS",SWIG_From_int(static_cast< int >(wxMGL_DOS)));
39045 SWIG_Python_SetConstant(d, "WINDOWS_OS2",SWIG_From_int(static_cast< int >(wxWINDOWS_OS2)));
39046 SWIG_Python_SetConstant(d, "UNIX",SWIG_From_int(static_cast< int >(wxUNIX)));
39047 SWIG_Python_SetConstant(d, "X11",SWIG_From_int(static_cast< int >(wxX11)));
39048 SWIG_Python_SetConstant(d, "PALMOS",SWIG_From_int(static_cast< int >(wxPALMOS)));
39049 SWIG_Python_SetConstant(d, "DOS",SWIG_From_int(static_cast< int >(wxDOS)));
39050 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
39051 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
39052 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
39053 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
39054 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
39055
39056 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
39057
39058 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
39059 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
39060 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
39061 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
39062 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
39063 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
39064 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
39065 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
39066 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
39067 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
39068 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
39069 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
39070 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
39071 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
39072 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
39073 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
39074 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
39075 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
39076 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
39077 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
39078 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
39079 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
39080 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
39081 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
39082 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
39083 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
39084 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
39085 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
39086 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
39087 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
39088 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
39089 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
39090 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
39091 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
39092 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
39093 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
39094 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
39095 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
39096 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
39097 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
39098 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
39099 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
39100 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
39101 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
39102 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
39103 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
39104 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
39105 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
39106 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
39107 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
39108 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
39109 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
39110 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
39111
39112 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
39113
39114 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
39115 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
39116 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
39117 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
39118 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
39119 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
39120 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
39121 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
39122 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
39123 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
39124 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
39125 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
39126 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
39127 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
39128 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
39129 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
39130 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
39131 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
39132 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
39133 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
39134 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
39135 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
39136 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
39137 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
39138 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
39139 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
39140 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
39141 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
39142 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
39143 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
39144 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
39145 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
39146 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
39147 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
39148 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
39149 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
39150 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
39151 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
39152 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
39153 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
39154 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
39155 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
39156 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
39157 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
39158 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
39159 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
39160 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
39161 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
39162 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
39163 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
39164 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
39165 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
39166 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
39167 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
39168 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
39169 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
39170 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
39171 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
39172 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
39173 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
39174 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
39175 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
39176 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
39177 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
39178 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
39179 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
39180 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
39181 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
39182 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
39183 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
39184 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
39185 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
39186 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
39187 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
39188 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
39189 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
39190
39191 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
39192
39193 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
39194 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
39195 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
39196 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
39197 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
39198 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
39199 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
39200 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
39201 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
39202 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
39203 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
39204 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
39205 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
39206 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
39207 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
39208 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
39209 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
39210 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
39211 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
39212 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
39213 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
39214 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
39215 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
39216 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
39217 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
39218 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
39219 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
39220 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
39221 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
39222 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
39223 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
39224 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
39225 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
39226 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
39227 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
39228 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
39229 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
39230 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
39231 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
39232 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
39233 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
39234 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
39235 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
39236 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
39237 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
39238 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
39239 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
39240 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
39241 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
39242 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
39243 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
39244 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
39245 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
39246 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
39247 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
39248 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
39249 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
39250 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
39251 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
39252 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
39253 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
39254 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
39255 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
39256 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
39257 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
39258 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
39259 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
39260 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
39261 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
39262 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
39263 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
39264 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
39265 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
39266 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
39267 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
39268 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
39269 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
39270 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
39271 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
39272 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
39273 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
39274 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
39275 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
39276 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
39277 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
39278 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
39279 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
39280 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
39281 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
39282 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
39283 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
39284 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
39285 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
39286 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
39287 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
39288 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
39289 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
39290 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
39291 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
39292 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
39293 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
39294 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
39295 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
39296 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
39297 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
39298 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
39299 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
39300 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
39301 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
39302 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
39303 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
39304 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
39305 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
39306 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
39307 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
39308 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
39309 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
39310 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
39311 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
39312 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
39313 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
39314 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
39315 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
39316 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
39317 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
39318 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
39319 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
39320 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
39321 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
39322 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
39323 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
39324 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
39325 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
39326 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
39327 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
39328 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
39329 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
39330 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
39331 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
39332 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
39333 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
39334 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
39335 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
39336 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
39337 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
39338 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
39339 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
39340 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
39341 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
39342 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
39343 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
39344 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
39345 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
39346 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
39347 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
39348 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
39349 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
39350 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
39351 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
39352 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
39353 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
39354 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
39355 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
39356 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
39357 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
39358 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
39359 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
39360 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
39361 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
39362 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
39363 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
39364 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
39365 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
39366 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
39367 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
39368 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
39369 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
39370 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
39371 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
39372 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
39373 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
39374 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
39375 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
39376 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
39377 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
39378 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
39379 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
39380 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
39381 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
39382 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
39383 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
39384 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
39385 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
39386 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
39387 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
39388 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
39389 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
39390 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
39391 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
39392 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
39393
39394 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
39395 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
39396 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
39397 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
39398
39399 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
39400 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_None",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_None)));
39401 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Messages",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Messages)));
39402 SWIG_Python_SetConstant(d, "StandardPaths_ResourceCat_Max",SWIG_From_int(static_cast< int >(wxStandardPaths::ResourceCat_Max)));
39403 SWIG_Python_SetConstant(d, "POWER_SOCKET",SWIG_From_int(static_cast< int >(wxPOWER_SOCKET)));
39404 SWIG_Python_SetConstant(d, "POWER_BATTERY",SWIG_From_int(static_cast< int >(wxPOWER_BATTERY)));
39405 SWIG_Python_SetConstant(d, "POWER_UNKNOWN",SWIG_From_int(static_cast< int >(wxPOWER_UNKNOWN)));
39406 SWIG_Python_SetConstant(d, "BATTERY_NORMAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_NORMAL_STATE)));
39407 SWIG_Python_SetConstant(d, "BATTERY_LOW_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_LOW_STATE)));
39408 SWIG_Python_SetConstant(d, "BATTERY_CRITICAL_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_CRITICAL_STATE)));
39409 SWIG_Python_SetConstant(d, "BATTERY_SHUTDOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_SHUTDOWN_STATE)));
39410 SWIG_Python_SetConstant(d, "BATTERY_UNKNOWN_STATE",SWIG_From_int(static_cast< int >(wxBATTERY_UNKNOWN_STATE)));
39411 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDING", PyInt_FromLong(wxEVT_POWER_SUSPENDING));
39412 PyDict_SetItemString(d, "wxEVT_POWER_SUSPENDED", PyInt_FromLong(wxEVT_POWER_SUSPENDED));
39413 PyDict_SetItemString(d, "wxEVT_POWER_SUSPEND_CANCEL", PyInt_FromLong(wxEVT_POWER_SUSPEND_CANCEL));
39414 PyDict_SetItemString(d, "wxEVT_POWER_RESUME", PyInt_FromLong(wxEVT_POWER_RESUME));
39415 }
39416
wxWidgets (Impactor)