]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wxTinderbox warning fix.
[wxWidgets.git] / wxPython / src / msw / _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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_char swig_types[0]
2463 #define SWIGTYPE_p_form_ops_t swig_types[1]
2464 #define SWIGTYPE_p_int swig_types[2]
2465 #define SWIGTYPE_p_unsigned_char swig_types[3]
2466 #define SWIGTYPE_p_unsigned_int swig_types[4]
2467 #define SWIGTYPE_p_unsigned_long swig_types[5]
2468 #define SWIGTYPE_p_void swig_types[6]
2469 #define SWIGTYPE_p_wxANIHandler swig_types[7]
2470 #define SWIGTYPE_p_wxAcceleratorTable swig_types[8]
2471 #define SWIGTYPE_p_wxActivateEvent swig_types[9]
2472 #define SWIGTYPE_p_wxArrayString swig_types[10]
2473 #define SWIGTYPE_p_wxBMPHandler swig_types[11]
2474 #define SWIGTYPE_p_wxBitmap swig_types[12]
2475 #define SWIGTYPE_p_wxBitmapDataObject swig_types[13]
2476 #define SWIGTYPE_p_wxBoxSizer swig_types[14]
2477 #define SWIGTYPE_p_wxBusyCursor swig_types[15]
2478 #define SWIGTYPE_p_wxBusyInfo swig_types[16]
2479 #define SWIGTYPE_p_wxCURHandler swig_types[17]
2480 #define SWIGTYPE_p_wxCaret swig_types[18]
2481 #define SWIGTYPE_p_wxChar swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboard swig_types[21]
2484 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
2485 #define SWIGTYPE_p_wxCloseEvent swig_types[23]
2486 #define SWIGTYPE_p_wxColour swig_types[24]
2487 #define SWIGTYPE_p_wxCommandEvent swig_types[25]
2488 #define SWIGTYPE_p_wxConfig swig_types[26]
2489 #define SWIGTYPE_p_wxConfigBase swig_types[27]
2490 #define SWIGTYPE_p_wxConfigPathChanger swig_types[28]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[29]
2492 #define SWIGTYPE_p_wxControl swig_types[30]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[31]
2494 #define SWIGTYPE_p_wxCursor swig_types[32]
2495 #define SWIGTYPE_p_wxCustomDataObject swig_types[33]
2496 #define SWIGTYPE_p_wxDC swig_types[34]
2497 #define SWIGTYPE_p_wxDataFormat swig_types[35]
2498 #define SWIGTYPE_p_wxDataObject swig_types[36]
2499 #define SWIGTYPE_p_wxDataObjectComposite swig_types[37]
2500 #define SWIGTYPE_p_wxDataObjectSimple swig_types[38]
2501 #define SWIGTYPE_p_wxDateEvent swig_types[39]
2502 #define SWIGTYPE_p_wxDateSpan swig_types[40]
2503 #define SWIGTYPE_p_wxDateTime swig_types[41]
2504 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[42]
2505 #define SWIGTYPE_p_wxDisplay swig_types[43]
2506 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[44]
2507 #define SWIGTYPE_p_wxDropFilesEvent swig_types[45]
2508 #define SWIGTYPE_p_wxDuplexMode swig_types[46]
2509 #define SWIGTYPE_p_wxEraseEvent swig_types[47]
2510 #define SWIGTYPE_p_wxEvent swig_types[48]
2511 #define SWIGTYPE_p_wxEvtHandler swig_types[49]
2512 #define SWIGTYPE_p_wxFSFile swig_types[50]
2513 #define SWIGTYPE_p_wxFileConfig swig_types[51]
2514 #define SWIGTYPE_p_wxFileDataObject swig_types[52]
2515 #define SWIGTYPE_p_wxFileHistory swig_types[53]
2516 #define SWIGTYPE_p_wxFileSystem swig_types[54]
2517 #define SWIGTYPE_p_wxFileType swig_types[55]
2518 #define SWIGTYPE_p_wxFileTypeInfo swig_types[56]
2519 #define SWIGTYPE_p_wxFlexGridSizer swig_types[57]
2520 #define SWIGTYPE_p_wxFocusEvent swig_types[58]
2521 #define SWIGTYPE_p_wxFont swig_types[59]
2522 #define SWIGTYPE_p_wxFrame swig_types[60]
2523 #define SWIGTYPE_p_wxGBSizerItem swig_types[61]
2524 #define SWIGTYPE_p_wxGIFHandler swig_types[62]
2525 #define SWIGTYPE_p_wxGridBagSizer swig_types[63]
2526 #define SWIGTYPE_p_wxGridSizer swig_types[64]
2527 #define SWIGTYPE_p_wxICOHandler swig_types[65]
2528 #define SWIGTYPE_p_wxIcon swig_types[66]
2529 #define SWIGTYPE_p_wxIconizeEvent swig_types[67]
2530 #define SWIGTYPE_p_wxIdleEvent swig_types[68]
2531 #define SWIGTYPE_p_wxImage swig_types[69]
2532 #define SWIGTYPE_p_wxImageHandler swig_types[70]
2533 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[71]
2534 #define SWIGTYPE_p_wxInitDialogEvent swig_types[72]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[73]
2536 #define SWIGTYPE_p_wxJoystick swig_types[74]
2537 #define SWIGTYPE_p_wxJoystickEvent swig_types[75]
2538 #define SWIGTYPE_p_wxKeyEvent swig_types[76]
2539 #define SWIGTYPE_p_wxKillError swig_types[77]
2540 #define SWIGTYPE_p_wxLayoutConstraints swig_types[78]
2541 #define SWIGTYPE_p_wxLog swig_types[79]
2542 #define SWIGTYPE_p_wxLogBuffer swig_types[80]
2543 #define SWIGTYPE_p_wxLogChain swig_types[81]
2544 #define SWIGTYPE_p_wxLogGui swig_types[82]
2545 #define SWIGTYPE_p_wxLogNull swig_types[83]
2546 #define SWIGTYPE_p_wxLogStderr swig_types[84]
2547 #define SWIGTYPE_p_wxLogTextCtrl swig_types[85]
2548 #define SWIGTYPE_p_wxLogWindow swig_types[86]
2549 #define SWIGTYPE_p_wxMaximizeEvent swig_types[87]
2550 #define SWIGTYPE_p_wxMemorySize swig_types[88]
2551 #define SWIGTYPE_p_wxMenu swig_types[89]
2552 #define SWIGTYPE_p_wxMenuBar swig_types[90]
2553 #define SWIGTYPE_p_wxMenuEvent swig_types[91]
2554 #define SWIGTYPE_p_wxMenuItem swig_types[92]
2555 #define SWIGTYPE_p_wxMetafile swig_types[93]
2556 #define SWIGTYPE_p_wxMetafileDataObject swig_types[94]
2557 #define SWIGTYPE_p_wxMimeTypesManager swig_types[95]
2558 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[96]
2559 #define SWIGTYPE_p_wxMouseEvent swig_types[97]
2560 #define SWIGTYPE_p_wxMouseState swig_types[98]
2561 #define SWIGTYPE_p_wxMoveEvent swig_types[99]
2562 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[100]
2563 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
2564 #define SWIGTYPE_p_wxNcPaintEvent swig_types[102]
2565 #define SWIGTYPE_p_wxNotifyEvent swig_types[103]
2566 #define SWIGTYPE_p_wxObject swig_types[104]
2567 #define SWIGTYPE_p_wxOutputStream swig_types[105]
2568 #define SWIGTYPE_p_wxPCXHandler swig_types[106]
2569 #define SWIGTYPE_p_wxPNGHandler swig_types[107]
2570 #define SWIGTYPE_p_wxPNMHandler swig_types[108]
2571 #define SWIGTYPE_p_wxPaintEvent swig_types[109]
2572 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[110]
2573 #define SWIGTYPE_p_wxPaperSize swig_types[111]
2574 #define SWIGTYPE_p_wxPoint swig_types[112]
2575 #define SWIGTYPE_p_wxProcessEvent swig_types[113]
2576 #define SWIGTYPE_p_wxPyApp swig_types[114]
2577 #define SWIGTYPE_p_wxPyArtProvider swig_types[115]
2578 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[116]
2579 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
2580 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[118]
2581 #define SWIGTYPE_p_wxPyDropSource swig_types[119]
2582 #define SWIGTYPE_p_wxPyDropTarget swig_types[120]
2583 #define SWIGTYPE_p_wxPyEvent swig_types[121]
2584 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[122]
2585 #define SWIGTYPE_p_wxPyImageHandler swig_types[123]
2586 #define SWIGTYPE_p_wxPyLog swig_types[124]
2587 #define SWIGTYPE_p_wxPyProcess swig_types[125]
2588 #define SWIGTYPE_p_wxPySizer swig_types[126]
2589 #define SWIGTYPE_p_wxPyTextDataObject swig_types[127]
2590 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[128]
2591 #define SWIGTYPE_p_wxPyTimer swig_types[129]
2592 #define SWIGTYPE_p_wxPyTipProvider swig_types[130]
2593 #define SWIGTYPE_p_wxPyValidator swig_types[131]
2594 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[132]
2595 #define SWIGTYPE_p_wxRect swig_types[133]
2596 #define SWIGTYPE_p_wxScrollEvent swig_types[134]
2597 #define SWIGTYPE_p_wxScrollWinEvent swig_types[135]
2598 #define SWIGTYPE_p_wxSetCursorEvent swig_types[136]
2599 #define SWIGTYPE_p_wxShowEvent swig_types[137]
2600 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[138]
2601 #define SWIGTYPE_p_wxSize swig_types[139]
2602 #define SWIGTYPE_p_wxSizeEvent swig_types[140]
2603 #define SWIGTYPE_p_wxSizer swig_types[141]
2604 #define SWIGTYPE_p_wxSizerItem swig_types[142]
2605 #define SWIGTYPE_p_wxSound swig_types[143]
2606 #define SWIGTYPE_p_wxStandardPaths swig_types[144]
2607 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[145]
2608 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[146]
2609 #define SWIGTYPE_p_wxStopWatch swig_types[147]
2610 #define SWIGTYPE_p_wxString swig_types[148]
2611 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[149]
2612 #define SWIGTYPE_p_wxSystemOptions swig_types[150]
2613 #define SWIGTYPE_p_wxSystemSettings swig_types[151]
2614 #define SWIGTYPE_p_wxTIFFHandler swig_types[152]
2615 #define SWIGTYPE_p_wxTextCtrl swig_types[153]
2616 #define SWIGTYPE_p_wxTextDataObject swig_types[154]
2617 #define SWIGTYPE_p_wxTimeSpan swig_types[155]
2618 #define SWIGTYPE_p_wxTimer swig_types[156]
2619 #define SWIGTYPE_p_wxTimerEvent swig_types[157]
2620 #define SWIGTYPE_p_wxTimerRunner swig_types[158]
2621 #define SWIGTYPE_p_wxTipProvider swig_types[159]
2622 #define SWIGTYPE_p_wxToolTip swig_types[160]
2623 #define SWIGTYPE_p_wxURLDataObject swig_types[161]
2624 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[162]
2625 #define SWIGTYPE_p_wxValidator swig_types[163]
2626 #define SWIGTYPE_p_wxVideoMode swig_types[164]
2627 #define SWIGTYPE_p_wxWindow swig_types[165]
2628 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[166]
2629 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[167]
2630 #define SWIGTYPE_p_wxWindowDisabler swig_types[168]
2631 #define SWIGTYPE_p_wxXPMHandler swig_types[169]
2632 static swig_type_info *swig_types[171];
2633 static swig_module_info swig_module = {swig_types, 170, 0, 0, 0, 0};
2634 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2635 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2636
2637 /* -------- TYPES TABLE (END) -------- */
2638
2639 #if (PY_VERSION_HEX <= 0x02000000)
2640 # if !defined(SWIG_PYTHON_CLASSIC)
2641 # error "This python version requires to use swig with the '-classic' option"
2642 # endif
2643 #endif
2644 #if (PY_VERSION_HEX <= 0x02020000)
2645 # error "This python version requires to use swig with the '-nomodern' option"
2646 #endif
2647 #if (PY_VERSION_HEX <= 0x02020000)
2648 # error "This python version requires to use swig with the '-nomodernargs' option"
2649 #endif
2650 #ifndef METH_O
2651 # error "This python version requires to use swig with the '-nofastunpack' option"
2652 #endif
2653
2654 /*-----------------------------------------------
2655 @(target):= _misc_.so
2656 ------------------------------------------------*/
2657 #define SWIG_init init_misc_
2658
2659 #define SWIG_name "_misc_"
2660
2661 #define SWIGVERSION 0x010329
2662
2663
2664 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2665 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2666
2667
2668 #include <stdexcept>
2669
2670
2671 namespace swig {
2672 class PyObject_ptr {
2673 protected:
2674 PyObject *_obj;
2675
2676 public:
2677 PyObject_ptr() :_obj(0)
2678 {
2679 }
2680
2681 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2682 {
2683 Py_XINCREF(_obj);
2684 }
2685
2686 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2687 {
2688 if (initial_ref) Py_XINCREF(_obj);
2689 }
2690
2691 PyObject_ptr & operator=(const PyObject_ptr& item)
2692 {
2693 Py_XINCREF(item._obj);
2694 Py_XDECREF(_obj);
2695 _obj = item._obj;
2696 return *this;
2697 }
2698
2699 ~PyObject_ptr()
2700 {
2701 Py_XDECREF(_obj);
2702 }
2703
2704 operator PyObject *() const
2705 {
2706 return _obj;
2707 }
2708
2709 PyObject *operator->() const
2710 {
2711 return _obj;
2712 }
2713 };
2714 }
2715
2716
2717 namespace swig {
2718 struct PyObject_var : PyObject_ptr {
2719 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2720
2721 PyObject_var & operator = (PyObject* obj)
2722 {
2723 Py_XDECREF(_obj);
2724 _obj = obj;
2725 return *this;
2726 }
2727 };
2728 }
2729
2730
2731 #include "wx/wxPython/wxPython.h"
2732 #include "wx/wxPython/pyclasses.h"
2733 #include "wx/wxPython/pyistream.h"
2734
2735 static const wxString wxPyEmptyString(wxEmptyString);
2736
2737
2738
2739 #define SWIG_From_long PyInt_FromLong
2740
2741
2742 SWIGINTERNINLINE PyObject *
2743 SWIG_From_int (int value)
2744 {
2745 return SWIG_From_long (value);
2746 }
2747
2748
2749 #include <limits.h>
2750 #ifndef LLONG_MIN
2751 # define LLONG_MIN LONG_LONG_MIN
2752 #endif
2753 #ifndef LLONG_MAX
2754 # define LLONG_MAX LONG_LONG_MAX
2755 #endif
2756 #ifndef ULLONG_MAX
2757 # define ULLONG_MAX ULONG_LONG_MAX
2758 #endif
2759
2760
2761 SWIGINTERN int
2762 SWIG_AsVal_long (PyObject* obj, long* val)
2763 {
2764 if (PyNumber_Check(obj)) {
2765 if (val) *val = PyInt_AsLong(obj);
2766 return SWIG_OK;
2767 }
2768 return SWIG_TypeError;
2769 }
2770
2771
2772 SWIGINTERN int
2773 SWIG_AsVal_int (PyObject * obj, int *val)
2774 {
2775 long v;
2776 int res = SWIG_AsVal_long (obj, &v);
2777 if (SWIG_IsOK(res)) {
2778 if ((v < INT_MIN || v > INT_MAX)) {
2779 return SWIG_OverflowError;
2780 } else {
2781 if (val) *val = static_cast< int >(v);
2782 }
2783 }
2784 return res;
2785 }
2786
2787 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
2788
2789 #include <wx/stockitem.h>
2790
2791 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
2792 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
2793 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
2794
2795 SWIGINTERN int
2796 SWIG_AsVal_bool (PyObject *obj, bool *val)
2797 {
2798 if (obj == Py_True) {
2799 if (val) *val = true;
2800 return SWIG_OK;
2801 } else if (obj == Py_False) {
2802 if (val) *val = false;
2803 return SWIG_OK;
2804 } else {
2805 long v = 0;
2806 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
2807 if (SWIG_IsOK(res) && val) *val = v ? true : false;
2808 return res;
2809 }
2810 }
2811
2812
2813 SWIGINTERN int
2814 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
2815 {
2816 long v = 0;
2817 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2818 return SWIG_TypeError;
2819 }
2820 else if (val)
2821 *val = (unsigned long)v;
2822 return SWIG_OK;
2823 }
2824
2825
2826 SWIGINTERNINLINE PyObject*
2827 SWIG_From_unsigned_SS_long (unsigned long value)
2828 {
2829 return (value > LONG_MAX) ?
2830 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
2831 }
2832
2833
2834 void* wxGetXDisplay()
2835 {
2836 #ifdef __WXGTK__
2837 return wxGetDisplay();
2838 #else
2839 return NULL;
2840 #endif
2841 }
2842
2843
2844 wxWindow* FindWindowAtPointer() {
2845 wxPoint unused;
2846 return wxFindWindowAtPointer(unused);
2847 }
2848
2849
2850 bool wxThread_IsMain() {
2851 #ifdef WXP_WITH_THREAD
2852 return wxThread::IsMain();
2853 #else
2854 return true;
2855 #endif
2856 }
2857
2858 SWIGINTERN void wxCaret_Destroy(wxCaret *self){
2859 delete self;
2860 }
2861
2862 #include <wx/snglinst.h>
2863
2864
2865 #ifdef __WXMSW__
2866 #include <wx/msw/private.h>
2867 #include <wx/dynload.h>
2868 #endif
2869
2870
2871
2872 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
2873 #if 0
2874 , int method
2875 #endif
2876 )
2877 {
2878 #ifdef __WXMSW__
2879 #if 0
2880 switch (method)
2881 {
2882 case 1:
2883 // This one only partially works. Appears to be an undocumented
2884 // "standard" convention that not all widgets adhear to. For
2885 // example, for some widgets backgrounds or non-client areas may
2886 // not be painted.
2887 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
2888 break;
2889
2890 case 2:
2891 #endif
2892 // This one works much better, nearly all widgets and their
2893 // children are captured correctly[**]. Prior to the big
2894 // background erase changes that Vadim did in 2004-2005 this
2895 // method failed badly on XP with Themes activated, most native
2896 // widgets draw only partially, if at all. Without themes it
2897 // worked just like on Win2k. After those changes this method
2898 // works very well.
2899 //
2900 // ** For example the radio buttons in a wxRadioBox are not its
2901 // children by default, but you can capture it via the panel
2902 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
2903 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2904 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2905 PRF_ERASEBKGND | PRF_OWNED );
2906 return true;
2907 #if 0
2908 break;
2909
2910 case 3:
2911 // This one is only defined in the latest SDK and is only
2912 // available on XP. MSDN says it is similar to sending WM_PRINT
2913 // so I expect that it will work similar to the above. Since it
2914 // is avaialble only on XP, it can't be compiled like this and
2915 // will have to be loaded dynamically.
2916 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
2917
2918 // fall through
2919
2920 case 4:
2921 // Use PrintWindow if available, or fallback to WM_PRINT
2922 // otherwise. Unfortunately using PrintWindow is even worse than
2923 // WM_PRINT. For most native widgets nothing is drawn to the dc
2924 // at all, with or without Themes.
2925 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
2926 static bool s_triedToLoad = false;
2927 static PrintWindow_t pfnPrintWindow = NULL;
2928 if ( !s_triedToLoad )
2929 {
2930
2931 s_triedToLoad = true;
2932 wxDynamicLibrary dllUser32(_T("user32.dll"));
2933 if ( dllUser32.IsLoaded() )
2934 {
2935 wxLogNull nolog; // Don't report errors here
2936 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
2937 }
2938 }
2939 if (pfnPrintWindow)
2940 {
2941 //printf("Using PrintWindow\n");
2942 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
2943 }
2944 else
2945 {
2946 //printf("Using WM_PRINT\n");
2947 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
2948 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
2949 PRF_ERASEBKGND | PRF_OWNED );
2950 }
2951 }
2952 #endif // 0
2953 #else
2954 return false;
2955 #endif // __WXMSW__
2956 }
2957
2958
2959
2960 #include <wx/tipdlg.h>
2961
2962
2963 SWIGINTERNINLINE PyObject *
2964 SWIG_From_size_t (size_t value)
2965 {
2966 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
2967 }
2968
2969
2970 class wxPyTipProvider : public wxTipProvider {
2971 public:
2972 wxPyTipProvider(size_t currentTip)
2973 : wxTipProvider(currentTip) {}
2974
2975 DEC_PYCALLBACK_STRING__pure(GetTip);
2976 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
2977 PYPRIVATE;
2978 };
2979
2980 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
2981 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
2982
2983
2984 SWIGINTERNINLINE int
2985 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2986 {
2987 unsigned long v;
2988 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2989 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2990 return res;
2991 }
2992
2993
2994 IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
2995
2996 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
2997
2998 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
2999 : wxTimer(owner, id)
3000 {
3001 if (owner == NULL)
3002 SetOwner(this);
3003 }
3004
3005
3006 SWIGINTERN swig_type_info*
3007 SWIG_pchar_descriptor()
3008 {
3009 static int init = 0;
3010 static swig_type_info* info = 0;
3011 if (!init) {
3012 info = SWIG_TypeQuery("_p_char");
3013 init = 1;
3014 }
3015 return info;
3016 }
3017
3018
3019 SWIGINTERNINLINE PyObject *
3020 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3021 {
3022 if (carray) {
3023 if (size > INT_MAX) {
3024 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3025 return pchar_descriptor ?
3026 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3027 } else {
3028 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3029 }
3030 } else {
3031 return SWIG_Py_Void();
3032 }
3033 }
3034
3035
3036 SWIGINTERNINLINE PyObject *
3037 SWIG_FromCharPtr(const char *cptr)
3038 {
3039 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3040 }
3041
3042
3043 SWIGINTERN int
3044 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3045 {
3046 unsigned long v;
3047 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3048 if (SWIG_IsOK(res)) {
3049 if ((v > UINT_MAX)) {
3050 return SWIG_OverflowError;
3051 } else {
3052 if (val) *val = static_cast< unsigned int >(v);
3053 }
3054 }
3055 return res;
3056 }
3057
3058 SWIGINTERN wxString wxLog_TimeStamp(){
3059 wxString msg;
3060 wxLog::TimeStamp(&msg);
3061 return msg;
3062 }
3063 SWIGINTERN void wxLog_Destroy(wxLog *self){ delete self; }
3064 // Make some wrappers that double any % signs so they are 'escaped'
3065 void wxPyLogFatalError(const wxString& msg)
3066 {
3067 wxString m(msg);
3068 m.Replace(wxT("%"), wxT("%%"));
3069 wxLogFatalError(m);
3070 }
3071
3072 void wxPyLogError(const wxString& msg)
3073 {
3074 wxString m(msg);
3075 m.Replace(wxT("%"), wxT("%%"));
3076 wxLogError(m);
3077 }
3078
3079 void wxPyLogWarning(const wxString& msg)
3080 {
3081 wxString m(msg);
3082 m.Replace(wxT("%"), wxT("%%"));
3083 wxLogWarning(m);
3084 }
3085
3086 void wxPyLogMessage(const wxString& msg)
3087 {
3088 wxString m(msg);
3089 m.Replace(wxT("%"), wxT("%%"));
3090 wxLogMessage(m);
3091 }
3092
3093 void wxPyLogInfo(const wxString& msg)
3094 {
3095 wxString m(msg);
3096 m.Replace(wxT("%"), wxT("%%"));
3097 wxLogInfo(m);
3098 }
3099
3100 void wxPyLogDebug(const wxString& msg)
3101 {
3102 wxString m(msg);
3103 m.Replace(wxT("%"), wxT("%%"));
3104 wxLogDebug(m);
3105 }
3106
3107 void wxPyLogVerbose(const wxString& msg)
3108 {
3109 wxString m(msg);
3110 m.Replace(wxT("%"), wxT("%%"));
3111 wxLogVerbose(m);
3112 }
3113
3114 void wxPyLogStatus(const wxString& msg)
3115 {
3116 wxString m(msg);
3117 m.Replace(wxT("%"), wxT("%%"));
3118 wxLogStatus(m);
3119 }
3120
3121 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
3122 {
3123 wxString m(msg);
3124 m.Replace(wxT("%"), wxT("%%"));
3125 wxLogStatus(pFrame, m);
3126 }
3127
3128 void wxPyLogSysError(const wxString& msg)
3129 {
3130 wxString m(msg);
3131 m.Replace(wxT("%"), wxT("%%"));
3132 wxLogSysError(m);
3133 }
3134
3135 void wxPyLogGeneric(unsigned long level, const wxString& msg)
3136 {
3137 wxString m(msg);
3138 m.Replace(wxT("%"), wxT("%%"));
3139 wxLogGeneric(level, m);
3140 }
3141
3142 void wxPyLogTrace(unsigned long mask, const wxString& msg)
3143 {
3144 wxString m(msg);
3145 m.Replace(wxT("%"), wxT("%%"));
3146 wxLogTrace(mask, m);
3147 }
3148
3149 void wxPyLogTrace(const wxString& mask, const wxString& msg)
3150 {
3151 wxString m(msg);
3152 m.Replace(wxT("%"), wxT("%%"));
3153 wxLogTrace(mask, m);
3154 }
3155
3156
3157
3158 // A wxLog class that can be derived from in wxPython
3159 class wxPyLog : public wxLog {
3160 public:
3161 wxPyLog() : wxLog() {}
3162
3163 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
3164 bool found;
3165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3166 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
3167 PyObject* s = wx2PyString(szString);
3168 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
3169 Py_DECREF(s);
3170 }
3171 wxPyEndBlockThreads(blocked);
3172 if (! found)
3173 wxLog::DoLog(level, szString, t);
3174 }
3175
3176 virtual void DoLogString(const wxChar *szString, time_t t) {
3177 bool found;
3178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3179 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
3180 PyObject* s = wx2PyString(szString);
3181 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
3182 Py_DECREF(s);
3183 }
3184 wxPyEndBlockThreads(blocked);
3185 if (! found)
3186 wxLog::DoLogString(szString, t);
3187 }
3188
3189 DEC_PYCALLBACK_VOID_(Flush);
3190 PYPRIVATE;
3191 };
3192 IMP_PYCALLBACK_VOID_(wxPyLog, wxLog, Flush);
3193
3194
3195
3196
3197 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
3198
3199
3200 #include <wx/joystick.h>
3201
3202
3203 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
3204 // A C++ stub class for wxJoystick for platforms that don't have it.
3205 class wxJoystick : public wxObject {
3206 public:
3207 wxJoystick(int joystick = wxJOYSTICK1) {
3208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3209 PyErr_SetString(PyExc_NotImplementedError,
3210 "wxJoystick is not available on this platform.");
3211 wxPyEndBlockThreads(blocked);
3212 }
3213 wxPoint GetPosition() { return wxPoint(-1,-1); }
3214 int GetZPosition() { return -1; }
3215 int GetButtonState() { return -1; }
3216 int GetPOVPosition() { return -1; }
3217 int GetPOVCTSPosition() { return -1; }
3218 int GetRudderPosition() { return -1; }
3219 int GetUPosition() { return -1; }
3220 int GetVPosition() { return -1; }
3221 int GetMovementThreshold() { return -1; }
3222 void SetMovementThreshold(int threshold) {}
3223
3224 bool IsOk(void) { return false; }
3225 int GetNumberJoysticks() { return -1; }
3226 int GetManufacturerId() { return -1; }
3227 int GetProductId() { return -1; }
3228 wxString GetProductName() { return wxEmptyString; }
3229 int GetXMin() { return -1; }
3230 int GetYMin() { return -1; }
3231 int GetZMin() { return -1; }
3232 int GetXMax() { return -1; }
3233 int GetYMax() { return -1; }
3234 int GetZMax() { return -1; }
3235 int GetNumberButtons() { return -1; }
3236 int GetNumberAxes() { return -1; }
3237 int GetMaxButtons() { return -1; }
3238 int GetMaxAxes() { return -1; }
3239 int GetPollingMin() { return -1; }
3240 int GetPollingMax() { return -1; }
3241 int GetRudderMin() { return -1; }
3242 int GetRudderMax() { return -1; }
3243 int GetUMin() { return -1; }
3244 int GetUMax() { return -1; }
3245 int GetVMin() { return -1; }
3246 int GetVMax() { return -1; }
3247
3248 bool HasRudder() { return false; }
3249 bool HasZ() { return false; }
3250 bool HasU() { return false; }
3251 bool HasV() { return false; }
3252 bool HasPOV() { return false; }
3253 bool HasPOV4Dir() { return false; }
3254 bool HasPOVCTS() { return false; }
3255
3256 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
3257 bool ReleaseCapture() { return false; }
3258 };
3259 #endif
3260
3261
3262 #include <wx/sound.h>
3263
3264
3265 #if !wxUSE_SOUND
3266 // A C++ stub class for wxWave for platforms that don't have it.
3267 class wxSound : public wxObject
3268 {
3269 public:
3270 wxSound() {
3271 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3272 PyErr_SetString(PyExc_NotImplementedError,
3273 "wxSound is not available on this platform.");
3274 wxPyEndBlockThreads(blocked);
3275 }
3276 wxSound(const wxString&/*, bool*/) {
3277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3278 PyErr_SetString(PyExc_NotImplementedError,
3279 "wxSound is not available on this platform.");
3280 wxPyEndBlockThreads(blocked);
3281 }
3282 wxSound(int, const wxByte*) {
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 PyErr_SetString(PyExc_NotImplementedError,
3285 "wxSound is not available on this platform.");
3286 wxPyEndBlockThreads(blocked);
3287 }
3288
3289 ~wxSound() {};
3290
3291 bool Create(const wxString&/*, bool*/) { return false; }
3292 bool Create(int, const wxByte*) { return false; };
3293 bool IsOk() { return false; };
3294 bool Play(unsigned) const { return false; }
3295 static bool Play(const wxString&, unsigned) { return false; }
3296 static void Stop() {}
3297 };
3298
3299 #endif
3300
3301 SWIGINTERN wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
3302 if (fileName.Length() == 0)
3303 return new wxSound;
3304 else
3305 return new wxSound(fileName);
3306 }
3307 SWIGINTERN wxSound *new_wxSound(PyObject *data){
3308 unsigned char* buffer; int size;
3309 wxSound *sound = NULL;
3310
3311 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3312 if (!PyArg_Parse(data, "t#", &buffer, &size))
3313 goto done;
3314 sound = new wxSound(size, buffer);
3315 done:
3316 wxPyEndBlockThreads(blocked);
3317 return sound;
3318 }
3319 SWIGINTERN bool wxSound_CreateFromData(wxSound *self,PyObject *data){
3320 #ifndef __WXMAC__
3321 unsigned char* buffer;
3322 int size;
3323 bool rv = false;
3324
3325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3326 if (!PyArg_Parse(data, "t#", &buffer, &size))
3327 goto done;
3328 rv = self->Create(size, buffer);
3329 done:
3330 wxPyEndBlockThreads(blocked);
3331 return rv;
3332 #else
3333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3334 PyErr_SetString(PyExc_NotImplementedError,
3335 "Create from data is not available on this platform.");
3336 wxPyEndBlockThreads(blocked);
3337 return false;
3338 #endif
3339 }
3340
3341 #include <wx/mimetype.h>
3342
3343 SWIGINTERN PyObject *wxFileType_GetMimeType(wxFileType *self){
3344 wxString str;
3345 if (self->GetMimeType(&str))
3346 return wx2PyString(str);
3347 else
3348 RETURN_NONE();
3349 }
3350 SWIGINTERN PyObject *wxFileType_GetMimeTypes(wxFileType *self){
3351 wxArrayString arr;
3352 if (self->GetMimeTypes(arr))
3353 return wxArrayString2PyList_helper(arr);
3354 else
3355 RETURN_NONE();
3356 }
3357 SWIGINTERN PyObject *wxFileType_GetExtensions(wxFileType *self){
3358 wxArrayString arr;
3359 if (self->GetExtensions(arr))
3360 return wxArrayString2PyList_helper(arr);
3361 else
3362 RETURN_NONE();
3363 }
3364 SWIGINTERN wxIcon *wxFileType_GetIcon(wxFileType *self){
3365 wxIconLocation loc;
3366 if (self->GetIcon(&loc))
3367 return new wxIcon(loc);
3368 else
3369 return NULL;
3370 }
3371 SWIGINTERN PyObject *wxFileType_GetIconInfo(wxFileType *self){
3372 wxIconLocation loc;
3373 if (self->GetIcon(&loc)) {
3374 wxString iconFile = loc.GetFileName();
3375 int iconIndex = -1;
3376
3377 iconIndex = loc.GetIndex();
3378
3379 // Make a tuple and put the values in it
3380 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3381 PyObject* tuple = PyTuple_New(3);
3382 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
3383 wxT("wxIcon"), true));
3384 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
3385 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
3386 wxPyEndBlockThreads(blocked);
3387 return tuple;
3388 }
3389 else
3390 RETURN_NONE();
3391 }
3392 SWIGINTERN PyObject *wxFileType_GetDescription(wxFileType *self){
3393 wxString str;
3394 if (self->GetDescription(&str))
3395 return wx2PyString(str);
3396 else
3397 RETURN_NONE();
3398 }
3399 SWIGINTERN PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3400 wxString str;
3401 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3402 return wx2PyString(str);
3403 else
3404 RETURN_NONE();
3405 }
3406 SWIGINTERN PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3407 wxString str;
3408 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
3409 return wx2PyString(str);
3410 else
3411 RETURN_NONE();
3412 }
3413 SWIGINTERN PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3414 wxArrayString verbs;
3415 wxArrayString commands;
3416 if (self->GetAllCommands(&verbs, &commands,
3417 wxFileType::MessageParameters(filename, mimetype))) {
3418 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3419 PyObject* tuple = PyTuple_New(2);
3420 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
3421 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
3422 wxPyEndBlockThreads(blocked);
3423 return tuple;
3424 }
3425 else
3426 RETURN_NONE();
3427 }
3428 SWIGINTERN wxString wxFileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
3429 return wxFileType::ExpandCommand(command,
3430 wxFileType::MessageParameters(filename, mimetype));
3431 }
3432 SWIGINTERN PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
3433 wxArrayString arr;
3434 self->EnumAllFileTypes(arr);
3435 return wxArrayString2PyList_helper(arr);
3436 }
3437
3438 #include <wx/artprov.h>
3439
3440 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
3441 static const wxString wxPyART_MENU(wxART_MENU);
3442 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
3443 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
3444 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
3445 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
3446 static const wxString wxPyART_BUTTON(wxART_BUTTON);
3447 static const wxString wxPyART_OTHER(wxART_OTHER);
3448 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
3449 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
3450 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
3451 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
3452 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
3453 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
3454 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
3455 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
3456 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
3457 static const wxString wxPyART_GO_UP(wxART_GO_UP);
3458 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
3459 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
3460 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
3461 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
3462 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
3463 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
3464 static const wxString wxPyART_PRINT(wxART_PRINT);
3465 static const wxString wxPyART_HELP(wxART_HELP);
3466 static const wxString wxPyART_TIP(wxART_TIP);
3467 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
3468 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
3469 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
3470 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
3471 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
3472 static const wxString wxPyART_CDROM(wxART_CDROM);
3473 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
3474 static const wxString wxPyART_FOLDER(wxART_FOLDER);
3475 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
3476 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
3477 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
3478 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
3479 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
3480 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
3481 static const wxString wxPyART_ERROR(wxART_ERROR);
3482 static const wxString wxPyART_QUESTION(wxART_QUESTION);
3483 static const wxString wxPyART_WARNING(wxART_WARNING);
3484 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
3485 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
3486 static const wxString wxPyART_COPY(wxART_COPY);
3487 static const wxString wxPyART_CUT(wxART_CUT);
3488 static const wxString wxPyART_PASTE(wxART_PASTE);
3489 static const wxString wxPyART_DELETE(wxART_DELETE);
3490 static const wxString wxPyART_NEW(wxART_NEW);
3491 static const wxString wxPyART_UNDO(wxART_UNDO);
3492 static const wxString wxPyART_REDO(wxART_REDO);
3493 static const wxString wxPyART_QUIT(wxART_QUIT);
3494 static const wxString wxPyART_FIND(wxART_FIND);
3495 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
3496 // Python aware wxArtProvider
3497 class wxPyArtProvider : public wxArtProvider {
3498 public:
3499
3500 virtual wxBitmap CreateBitmap(const wxArtID& id,
3501 const wxArtClient& client,
3502 const wxSize& size) {
3503 wxBitmap rval = wxNullBitmap;
3504 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3505 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
3506 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
3507 PyObject* ro;
3508 wxBitmap* ptr;
3509 PyObject* s1, *s2;
3510 s1 = wx2PyString(id);
3511 s2 = wx2PyString(client);
3512 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
3513 Py_DECREF(so);
3514 Py_DECREF(s1);
3515 Py_DECREF(s2);
3516 if (ro) {
3517 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
3518 rval = *ptr;
3519 Py_DECREF(ro);
3520 }
3521 }
3522 wxPyEndBlockThreads(blocked);
3523 return rval;
3524 }
3525
3526 PYPRIVATE;
3527 };
3528
3529 SWIGINTERN void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
3530
3531
3532
3533 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
3534 PyObject* ret = PyTuple_New(3);
3535 if (ret) {
3536 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
3537 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
3538 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
3539 }
3540 return ret;
3541 }
3542
3543 SWIGINTERN PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
3544 bool cont;
3545 long index = 0;
3546 wxString value;
3547
3548 cont = self->GetFirstGroup(value, index);
3549 return __EnumerationHelper(cont, value, index);
3550 }
3551 SWIGINTERN PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
3552 bool cont;
3553 wxString value;
3554
3555 cont = self->GetNextGroup(value, index);
3556 return __EnumerationHelper(cont, value, index);
3557 }
3558 SWIGINTERN PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
3559 bool cont;
3560 long index = 0;
3561 wxString value;
3562
3563 cont = self->GetFirstEntry(value, index);
3564 return __EnumerationHelper(cont, value, index);
3565 }
3566 SWIGINTERN PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
3567 bool cont;
3568 wxString value;
3569
3570 cont = self->GetNextEntry(value, index);
3571 return __EnumerationHelper(cont, value, index);
3572 }
3573 SWIGINTERN long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
3574 long rv;
3575 self->Read(key, &rv, defaultVal);
3576 return rv;
3577 }
3578
3579 SWIGINTERN int
3580 SWIG_AsVal_double (PyObject *obj, double* val)
3581 {
3582 if (PyNumber_Check(obj)) {
3583 if (val) *val = PyFloat_AsDouble(obj);
3584 return SWIG_OK;
3585 }
3586 return SWIG_TypeError;
3587 }
3588
3589 SWIGINTERN double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
3590 double rv;
3591 self->Read(key, &rv, defaultVal);
3592 return rv;
3593 }
3594
3595 #define SWIG_From_double PyFloat_FromDouble
3596
3597 SWIGINTERN bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
3598 bool rv;
3599 self->Read(key, &rv, defaultVal);
3600 return rv;
3601 }
3602
3603 #include <wx/datetime.h>
3604
3605 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
3606 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
3607
3608 #define LOCAL_TZ wxDateTime::Local
3609
3610 SWIGINTERN PyObject *wxDateTime_GetAmPmStrings(){
3611 wxString am;
3612 wxString pm;
3613 wxDateTime::GetAmPmStrings(&am, &pm);
3614 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3615 PyObject* tup = PyTuple_New(2);
3616 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
3617 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
3618 wxPyEndBlockThreads(blocked);
3619 return tup;
3620 }
3621
3622 SWIGINTERNINLINE PyObject *
3623 SWIG_From_unsigned_SS_int (unsigned int value)
3624 {
3625 return SWIG_From_unsigned_SS_long (value);
3626 }
3627
3628 SWIGINTERN wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
3629 SWIGINTERN wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
3630 SWIGINTERN wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
3631 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
3632 SWIGINTERN wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
3633 SWIGINTERN bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
3634 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
3635 return (*self < *other);
3636 }
3637 SWIGINTERN bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
3638 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
3639 return (*self <= *other);
3640 }
3641 SWIGINTERN bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
3642 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
3643 return (*self > *other);
3644 }
3645 SWIGINTERN bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
3646 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
3647 return (*self >= *other);
3648 }
3649 SWIGINTERN bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
3650 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
3651 return (*self == *other);
3652 }
3653 SWIGINTERN bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
3654 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
3655 return (*self != *other);
3656 }
3657 SWIGINTERN int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
3658 const wxChar* rv;
3659 const wxChar* _date = date;
3660 rv = self->ParseRfc822Date(_date);
3661 if (rv == NULL) return -1;
3662 return rv - _date;
3663 }
3664 SWIGINTERN int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
3665 const wxChar* rv;
3666 const wxChar* _date = date;
3667 rv = self->ParseFormat(_date, format, dateDef);
3668 if (rv == NULL) return -1;
3669 return rv - _date;
3670 }
3671 SWIGINTERN int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
3672 const wxChar* rv;
3673 const wxChar* _datetime = datetime;
3674 rv = self->ParseDateTime(_datetime);
3675 if (rv == NULL) return -1;
3676 return rv - _datetime;
3677 }
3678 SWIGINTERN int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
3679 const wxChar* rv;
3680 const wxChar* _date = date;
3681 rv = self->ParseDate(_date);
3682 if (rv == NULL) return -1;
3683 return rv - _date;
3684 }
3685 SWIGINTERN int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
3686 const wxChar* rv;
3687 const wxChar* _time = time;
3688 rv = self->ParseTime(_time);
3689 if (rv == NULL) return -1;
3690 return rv - _time;
3691 }
3692 SWIGINTERN wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
3693 SWIGINTERN wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
3694 SWIGINTERN wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
3695 SWIGINTERN wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
3696 SWIGINTERN bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
3697 SWIGINTERN bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
3698 SWIGINTERN bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
3699 SWIGINTERN bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
3700 SWIGINTERN bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
3701 SWIGINTERN bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
3702 SWIGINTERN wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
3703 SWIGINTERN wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
3704 SWIGINTERN wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
3705 SWIGINTERN wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
3706 SWIGINTERN bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
3707 SWIGINTERN bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
3708
3709 #include <wx/dataobj.h>
3710
3711 SWIGINTERN PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
3712 size_t count = self->GetFormatCount(dir);
3713 wxDataFormat* formats = new wxDataFormat[count];
3714 self->GetAllFormats(formats, dir);
3715
3716 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3717 PyObject* list = PyList_New(count);
3718 for (size_t i=0; i<count; i++) {
3719 wxDataFormat* format = new wxDataFormat(formats[i]);
3720 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
3721 PyList_SET_ITEM(list, i, obj); // PyList_SET_ITEM steals a reference
3722 }
3723 wxPyEndBlockThreads(blocked);
3724 delete [] formats;
3725 return list;
3726 }
3727 SWIGINTERN PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
3728 PyObject* rval = NULL;
3729 size_t size = self->GetDataSize(format);
3730 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3731 if (size) {
3732 char* buf = new char[size];
3733 if (self->GetDataHere(format, buf))
3734 rval = PyString_FromStringAndSize(buf, size);
3735 delete [] buf;
3736 }
3737 if (! rval) {
3738 rval = Py_None;
3739 Py_INCREF(rval);
3740 }
3741 wxPyEndBlockThreads(blocked);
3742 return rval;
3743 }
3744 SWIGINTERN bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
3745 bool rval;
3746 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3747 if (PyString_Check(data)) {
3748 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
3749 }
3750 else {
3751 // raise a TypeError if not a string
3752 PyErr_SetString(PyExc_TypeError, "String expected.");
3753 rval = false;
3754 }
3755 wxPyEndBlockThreads(blocked);
3756 return rval;
3757 }
3758 SWIGINTERN PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
3759 PyObject* rval = NULL;
3760 size_t size = self->GetDataSize();
3761 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3762 if (size) {
3763 char* buf = new char[size];
3764 if (self->GetDataHere(buf))
3765 rval = PyString_FromStringAndSize(buf, size);
3766 delete [] buf;
3767 }
3768 if (! rval) {
3769 rval = Py_None;
3770 Py_INCREF(rval);
3771 }
3772 wxPyEndBlockThreads(blocked);
3773 return rval;
3774 }
3775 SWIGINTERN bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
3776 bool rval;
3777 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3778 if (PyString_Check(data)) {
3779 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3780 }
3781 else {
3782 // raise a TypeError if not a string
3783 PyErr_SetString(PyExc_TypeError, "String expected.");
3784 rval = false;
3785 }
3786 wxPyEndBlockThreads(blocked);
3787 return rval;
3788 }
3789 // Create a new class for wxPython to use
3790 class wxPyDataObjectSimple : public wxDataObjectSimple {
3791 public:
3792 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
3793 : wxDataObjectSimple(format) {}
3794
3795 DEC_PYCALLBACK_SIZET__const(GetDataSize);
3796 bool GetDataHere(void *buf) const;
3797 bool SetData(size_t len, const void *buf) const;
3798 PYPRIVATE;
3799 };
3800
3801 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
3802
3803 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
3804 // We need to get the data for this object and write it to buf. I think
3805 // the best way to do this for wxPython is to have the Python method
3806 // return either a string or None and then act appropriately with the
3807 // C++ version.
3808
3809 bool rval = false;
3810 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3811 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
3812 PyObject* ro;
3813 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3814 if (ro) {
3815 rval = (ro != Py_None && PyString_Check(ro));
3816 if (rval)
3817 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
3818 Py_DECREF(ro);
3819 }
3820 }
3821 wxPyEndBlockThreads(blocked);
3822 return rval;
3823 }
3824
3825 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
3826 // For this one we simply need to make a string from buf and len
3827 // and send it to the Python method.
3828 bool rval = false;
3829 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3830 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
3831 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
3832 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
3833 Py_DECREF(data);
3834 }
3835 wxPyEndBlockThreads(blocked);
3836 return rval;
3837 }
3838
3839 // Create a new class for wxPython to use
3840 class wxPyTextDataObject : public wxTextDataObject {
3841 public:
3842 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
3843 : wxTextDataObject(text) {}
3844
3845 DEC_PYCALLBACK_SIZET__const(GetTextLength);
3846 DEC_PYCALLBACK_STRING__const(GetText);
3847 DEC_PYCALLBACK__STRING(SetText);
3848 PYPRIVATE;
3849 };
3850
3851 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
3852 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
3853 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
3854
3855
3856 // Create a new class for wxPython to use
3857 class wxPyBitmapDataObject : public wxBitmapDataObject {
3858 public:
3859 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
3860 : wxBitmapDataObject(bitmap) {}
3861
3862 wxBitmap GetBitmap() const;
3863 void SetBitmap(const wxBitmap& bitmap);
3864 PYPRIVATE;
3865 };
3866
3867 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
3868 wxBitmap* rval = &wxNullBitmap;
3869 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3870 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
3871 PyObject* ro;
3872 wxBitmap* ptr;
3873 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
3874 if (ro) {
3875 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
3876 rval = ptr;
3877 Py_DECREF(ro);
3878 }
3879 }
3880 wxPyEndBlockThreads(blocked);
3881 return *rval;
3882 }
3883
3884 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
3885 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3886 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
3887 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
3888 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
3889 Py_DECREF(bo);
3890 }
3891 wxPyEndBlockThreads(blocked);
3892 }
3893
3894 SWIGINTERN wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
3895 return new wxCustomDataObject(wxDataFormat(formatName));
3896 }
3897 SWIGINTERN bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
3898 bool rval;
3899 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3900 if (PyString_Check(data)) {
3901 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
3902 }
3903 else {
3904 // raise a TypeError if not a string
3905 PyErr_SetString(PyExc_TypeError, "String expected.");
3906 rval = false;
3907 }
3908 wxPyEndBlockThreads(blocked);
3909 return rval;
3910 }
3911 SWIGINTERN PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
3912 PyObject* obj;
3913 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3914 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
3915 wxPyEndBlockThreads(blocked);
3916 return obj;
3917 }
3918
3919 #include <wx/metafile.h>
3920
3921
3922 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
3923
3924
3925 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
3926 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
3927 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
3928 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
3929 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
3930
3931
3932 class wxPyTextDropTarget : public wxTextDropTarget {
3933 public:
3934 wxPyTextDropTarget() {}
3935
3936 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
3937
3938 DEC_PYCALLBACK__(OnLeave);
3939 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3940 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3941 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3942 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3943
3944 PYPRIVATE;
3945 };
3946
3947 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
3948 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
3949 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
3950 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
3951 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
3952 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
3953
3954
3955
3956 class wxPyFileDropTarget : public wxFileDropTarget {
3957 public:
3958 wxPyFileDropTarget() {}
3959
3960 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
3961
3962 DEC_PYCALLBACK__(OnLeave);
3963 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
3964 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
3965 DEC_PYCALLBACK_DR_2WXCDR(OnData);
3966 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
3967
3968 PYPRIVATE;
3969 };
3970
3971 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
3972 const wxArrayString& filenames) {
3973 bool rval = false;
3974 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3975 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
3976 PyObject* list = wxArrayString2PyList_helper(filenames);
3977 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
3978 Py_DECREF(list);
3979 }
3980 wxPyEndBlockThreads(blocked);
3981 return rval;
3982 }
3983
3984
3985
3986 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
3987 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
3988 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
3989 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
3990 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
3991
3992
3993
3994
3995 SWIGINTERN bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
3996
3997 #include <wx/display.h>
3998
3999 SWIGINTERN bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
4000 SWIGINTERN bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
4001
4002 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
4003 #if !wxUSE_DISPLAY
4004 #include <wx/dynarray.h>
4005 #include <wx/vidmode.h>
4006
4007 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
4008 #include "wx/arrimpl.cpp"
4009 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
4010 const wxVideoMode wxDefaultVideoMode;
4011
4012 class wxDisplay
4013 {
4014 public:
4015 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
4016 ~wxDisplay() {}
4017
4018 static size_t GetCount()
4019 { wxPyRaiseNotImplemented(); return 0; }
4020
4021 static int GetFromPoint(const wxPoint& pt)
4022 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
4023 static int GetFromWindow(wxWindow *window)
4024 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
4025
4026 virtual bool IsOk() const { return false; }
4027 virtual wxRect GetGeometry() const { wxRect r; return r; }
4028 virtual wxString GetName() const { return wxEmptyString; }
4029 bool IsPrimary() const { return false; }
4030
4031 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
4032 { wxArrayVideoModes a; return a; }
4033
4034 virtual wxVideoMode GetCurrentMode() const
4035 { return wxDefaultVideoMode; }
4036
4037 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
4038 { return false; }
4039
4040 void ResetMode() {}
4041 };
4042 #endif
4043
4044 SWIGINTERN PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
4045 PyObject* pyList = NULL;
4046 wxArrayVideoModes arr = self->GetModes(mode);
4047 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4048 pyList = PyList_New(0);
4049 for (int i=0; i < arr.GetCount(); i++) {
4050 wxVideoMode* m = new wxVideoMode(arr.Item(i));
4051 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
4052 PyList_Append(pyList, pyObj);
4053 Py_DECREF(pyObj);
4054 }
4055 wxPyEndBlockThreads(blocked);
4056 return pyList;
4057 }
4058
4059 #include <wx/stdpaths.h>
4060
4061 SWIGINTERN wxStandardPaths *wxStandardPaths_Get(){
4062 return (wxStandardPaths*) &wxStandardPaths::Get();
4063 }
4064 SWIGINTERN void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
4065 SWIGINTERN wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
4066 #ifdef __cplusplus
4067 extern "C" {
4068 #endif
4069 SWIGINTERN PyObject *_wrap_SystemSettings_GetColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4070 PyObject *resultobj = 0;
4071 wxSystemColour arg1 ;
4072 wxColour result;
4073 int val1 ;
4074 int ecode1 = 0 ;
4075 PyObject * obj0 = 0 ;
4076 char * kwnames[] = {
4077 (char *) "index", NULL
4078 };
4079
4080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) SWIG_fail;
4081 ecode1 = SWIG_AsVal_int(obj0, &val1);
4082 if (!SWIG_IsOK(ecode1)) {
4083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetColour" "', expected argument " "1"" of type '" "wxSystemColour""'");
4084 }
4085 arg1 = static_cast< wxSystemColour >(val1);
4086 {
4087 if (!wxPyCheckForApp()) SWIG_fail;
4088 PyThreadState* __tstate = wxPyBeginAllowThreads();
4089 result = wxSystemSettings::GetColour(arg1);
4090 wxPyEndAllowThreads(__tstate);
4091 if (PyErr_Occurred()) SWIG_fail;
4092 }
4093 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
4094 return resultobj;
4095 fail:
4096 return NULL;
4097 }
4098
4099
4100 SWIGINTERN PyObject *_wrap_SystemSettings_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4101 PyObject *resultobj = 0;
4102 wxSystemFont arg1 ;
4103 wxFont result;
4104 int val1 ;
4105 int ecode1 = 0 ;
4106 PyObject * obj0 = 0 ;
4107 char * kwnames[] = {
4108 (char *) "index", NULL
4109 };
4110
4111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) SWIG_fail;
4112 ecode1 = SWIG_AsVal_int(obj0, &val1);
4113 if (!SWIG_IsOK(ecode1)) {
4114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetFont" "', expected argument " "1"" of type '" "wxSystemFont""'");
4115 }
4116 arg1 = static_cast< wxSystemFont >(val1);
4117 {
4118 if (!wxPyCheckForApp()) SWIG_fail;
4119 PyThreadState* __tstate = wxPyBeginAllowThreads();
4120 result = wxSystemSettings::GetFont(arg1);
4121 wxPyEndAllowThreads(__tstate);
4122 if (PyErr_Occurred()) SWIG_fail;
4123 }
4124 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
4125 return resultobj;
4126 fail:
4127 return NULL;
4128 }
4129
4130
4131 SWIGINTERN PyObject *_wrap_SystemSettings_GetMetric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4132 PyObject *resultobj = 0;
4133 wxSystemMetric arg1 ;
4134 wxWindow *arg2 = (wxWindow *) NULL ;
4135 int result;
4136 int val1 ;
4137 int ecode1 = 0 ;
4138 void *argp2 = 0 ;
4139 int res2 = 0 ;
4140 PyObject * obj0 = 0 ;
4141 PyObject * obj1 = 0 ;
4142 char * kwnames[] = {
4143 (char *) "index",(char *) "win", NULL
4144 };
4145
4146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SystemSettings_GetMetric",kwnames,&obj0,&obj1)) SWIG_fail;
4147 ecode1 = SWIG_AsVal_int(obj0, &val1);
4148 if (!SWIG_IsOK(ecode1)) {
4149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_GetMetric" "', expected argument " "1"" of type '" "wxSystemMetric""'");
4150 }
4151 arg1 = static_cast< wxSystemMetric >(val1);
4152 if (obj1) {
4153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
4154 if (!SWIG_IsOK(res2)) {
4155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SystemSettings_GetMetric" "', expected argument " "2"" of type '" "wxWindow *""'");
4156 }
4157 arg2 = reinterpret_cast< wxWindow * >(argp2);
4158 }
4159 {
4160 if (!wxPyCheckForApp()) SWIG_fail;
4161 PyThreadState* __tstate = wxPyBeginAllowThreads();
4162 result = (int)wxSystemSettings::GetMetric(arg1,arg2);
4163 wxPyEndAllowThreads(__tstate);
4164 if (PyErr_Occurred()) SWIG_fail;
4165 }
4166 resultobj = SWIG_From_int(static_cast< int >(result));
4167 return resultobj;
4168 fail:
4169 return NULL;
4170 }
4171
4172
4173 SWIGINTERN PyObject *_wrap_SystemSettings_HasFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4174 PyObject *resultobj = 0;
4175 wxSystemFeature arg1 ;
4176 bool result;
4177 int val1 ;
4178 int ecode1 = 0 ;
4179 PyObject * obj0 = 0 ;
4180 char * kwnames[] = {
4181 (char *) "index", NULL
4182 };
4183
4184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) SWIG_fail;
4185 ecode1 = SWIG_AsVal_int(obj0, &val1);
4186 if (!SWIG_IsOK(ecode1)) {
4187 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_HasFeature" "', expected argument " "1"" of type '" "wxSystemFeature""'");
4188 }
4189 arg1 = static_cast< wxSystemFeature >(val1);
4190 {
4191 if (!wxPyCheckForApp()) SWIG_fail;
4192 PyThreadState* __tstate = wxPyBeginAllowThreads();
4193 result = (bool)wxSystemSettings::HasFeature(arg1);
4194 wxPyEndAllowThreads(__tstate);
4195 if (PyErr_Occurred()) SWIG_fail;
4196 }
4197 {
4198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4199 }
4200 return resultobj;
4201 fail:
4202 return NULL;
4203 }
4204
4205
4206 SWIGINTERN PyObject *_wrap_SystemSettings_GetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4207 PyObject *resultobj = 0;
4208 wxSystemScreenType result;
4209
4210 if (!SWIG_Python_UnpackTuple(args,"SystemSettings_GetScreenType",0,0,0)) SWIG_fail;
4211 {
4212 if (!wxPyCheckForApp()) SWIG_fail;
4213 PyThreadState* __tstate = wxPyBeginAllowThreads();
4214 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
4215 wxPyEndAllowThreads(__tstate);
4216 if (PyErr_Occurred()) SWIG_fail;
4217 }
4218 resultobj = SWIG_From_int(static_cast< int >(result));
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 SWIGINTERN PyObject *_wrap_SystemSettings_SetScreenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj = 0;
4227 wxSystemScreenType arg1 ;
4228 int val1 ;
4229 int ecode1 = 0 ;
4230 PyObject * obj0 = 0 ;
4231 char * kwnames[] = {
4232 (char *) "screen", NULL
4233 };
4234
4235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) SWIG_fail;
4236 ecode1 = SWIG_AsVal_int(obj0, &val1);
4237 if (!SWIG_IsOK(ecode1)) {
4238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SystemSettings_SetScreenType" "', expected argument " "1"" of type '" "wxSystemScreenType""'");
4239 }
4240 arg1 = static_cast< wxSystemScreenType >(val1);
4241 {
4242 if (!wxPyCheckForApp()) SWIG_fail;
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 wxSystemSettings::SetScreenType(arg1);
4245 wxPyEndAllowThreads(__tstate);
4246 if (PyErr_Occurred()) SWIG_fail;
4247 }
4248 resultobj = SWIG_Py_Void();
4249 return resultobj;
4250 fail:
4251 return NULL;
4252 }
4253
4254
4255 SWIGINTERN PyObject *SystemSettings_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4256 PyObject *obj;
4257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4258 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemSettings, SWIG_NewClientData(obj));
4259 return SWIG_Py_Void();
4260 }
4261
4262 SWIGINTERN int WINDOW_DEFAULT_VARIANT_set(PyObject *) {
4263 SWIG_Error(SWIG_AttributeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
4264 return 1;
4265 }
4266
4267
4268 SWIGINTERN PyObject *WINDOW_DEFAULT_VARIANT_get(void) {
4269 PyObject *pyobj = 0;
4270
4271 {
4272 #if wxUSE_UNICODE
4273 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4274 #else
4275 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
4276 #endif
4277 }
4278 return pyobj;
4279 }
4280
4281
4282 SWIGINTERN PyObject *_wrap_new_SystemOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4283 PyObject *resultobj = 0;
4284 wxSystemOptions *result = 0 ;
4285
4286 if (!SWIG_Python_UnpackTuple(args,"new_SystemOptions",0,0,0)) SWIG_fail;
4287 {
4288 PyThreadState* __tstate = wxPyBeginAllowThreads();
4289 result = (wxSystemOptions *)new wxSystemOptions();
4290 wxPyEndAllowThreads(__tstate);
4291 if (PyErr_Occurred()) SWIG_fail;
4292 }
4293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSystemOptions, SWIG_POINTER_NEW | 0 );
4294 return resultobj;
4295 fail:
4296 return NULL;
4297 }
4298
4299
4300 SWIGINTERN PyObject *_wrap_SystemOptions_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4301 PyObject *resultobj = 0;
4302 wxString *arg1 = 0 ;
4303 wxString *arg2 = 0 ;
4304 bool temp1 = false ;
4305 bool temp2 = false ;
4306 PyObject * obj0 = 0 ;
4307 PyObject * obj1 = 0 ;
4308 char * kwnames[] = {
4309 (char *) "name",(char *) "value", NULL
4310 };
4311
4312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) SWIG_fail;
4313 {
4314 arg1 = wxString_in_helper(obj0);
4315 if (arg1 == NULL) SWIG_fail;
4316 temp1 = true;
4317 }
4318 {
4319 arg2 = wxString_in_helper(obj1);
4320 if (arg2 == NULL) SWIG_fail;
4321 temp2 = true;
4322 }
4323 {
4324 PyThreadState* __tstate = wxPyBeginAllowThreads();
4325 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
4326 wxPyEndAllowThreads(__tstate);
4327 if (PyErr_Occurred()) SWIG_fail;
4328 }
4329 resultobj = SWIG_Py_Void();
4330 {
4331 if (temp1)
4332 delete arg1;
4333 }
4334 {
4335 if (temp2)
4336 delete arg2;
4337 }
4338 return resultobj;
4339 fail:
4340 {
4341 if (temp1)
4342 delete arg1;
4343 }
4344 {
4345 if (temp2)
4346 delete arg2;
4347 }
4348 return NULL;
4349 }
4350
4351
4352 SWIGINTERN PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4353 PyObject *resultobj = 0;
4354 wxString *arg1 = 0 ;
4355 int arg2 ;
4356 bool temp1 = false ;
4357 int val2 ;
4358 int ecode2 = 0 ;
4359 PyObject * obj0 = 0 ;
4360 PyObject * obj1 = 0 ;
4361 char * kwnames[] = {
4362 (char *) "name",(char *) "value", NULL
4363 };
4364
4365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
4366 {
4367 arg1 = wxString_in_helper(obj0);
4368 if (arg1 == NULL) SWIG_fail;
4369 temp1 = true;
4370 }
4371 ecode2 = SWIG_AsVal_int(obj1, &val2);
4372 if (!SWIG_IsOK(ecode2)) {
4373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SystemOptions_SetOptionInt" "', expected argument " "2"" of type '" "int""'");
4374 }
4375 arg2 = static_cast< int >(val2);
4376 {
4377 PyThreadState* __tstate = wxPyBeginAllowThreads();
4378 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
4379 wxPyEndAllowThreads(__tstate);
4380 if (PyErr_Occurred()) SWIG_fail;
4381 }
4382 resultobj = SWIG_Py_Void();
4383 {
4384 if (temp1)
4385 delete arg1;
4386 }
4387 return resultobj;
4388 fail:
4389 {
4390 if (temp1)
4391 delete arg1;
4392 }
4393 return NULL;
4394 }
4395
4396
4397 SWIGINTERN PyObject *_wrap_SystemOptions_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4398 PyObject *resultobj = 0;
4399 wxString *arg1 = 0 ;
4400 wxString result;
4401 bool temp1 = false ;
4402 PyObject * obj0 = 0 ;
4403 char * kwnames[] = {
4404 (char *) "name", NULL
4405 };
4406
4407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) SWIG_fail;
4408 {
4409 arg1 = wxString_in_helper(obj0);
4410 if (arg1 == NULL) SWIG_fail;
4411 temp1 = true;
4412 }
4413 {
4414 PyThreadState* __tstate = wxPyBeginAllowThreads();
4415 result = wxSystemOptions::GetOption((wxString const &)*arg1);
4416 wxPyEndAllowThreads(__tstate);
4417 if (PyErr_Occurred()) SWIG_fail;
4418 }
4419 {
4420 #if wxUSE_UNICODE
4421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4422 #else
4423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4424 #endif
4425 }
4426 {
4427 if (temp1)
4428 delete arg1;
4429 }
4430 return resultobj;
4431 fail:
4432 {
4433 if (temp1)
4434 delete arg1;
4435 }
4436 return NULL;
4437 }
4438
4439
4440 SWIGINTERN PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4441 PyObject *resultobj = 0;
4442 wxString *arg1 = 0 ;
4443 int result;
4444 bool temp1 = false ;
4445 PyObject * obj0 = 0 ;
4446 char * kwnames[] = {
4447 (char *) "name", NULL
4448 };
4449
4450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) SWIG_fail;
4451 {
4452 arg1 = wxString_in_helper(obj0);
4453 if (arg1 == NULL) SWIG_fail;
4454 temp1 = true;
4455 }
4456 {
4457 PyThreadState* __tstate = wxPyBeginAllowThreads();
4458 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
4459 wxPyEndAllowThreads(__tstate);
4460 if (PyErr_Occurred()) SWIG_fail;
4461 }
4462 resultobj = SWIG_From_int(static_cast< int >(result));
4463 {
4464 if (temp1)
4465 delete arg1;
4466 }
4467 return resultobj;
4468 fail:
4469 {
4470 if (temp1)
4471 delete arg1;
4472 }
4473 return NULL;
4474 }
4475
4476
4477 SWIGINTERN PyObject *_wrap_SystemOptions_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4478 PyObject *resultobj = 0;
4479 wxString *arg1 = 0 ;
4480 bool result;
4481 bool temp1 = false ;
4482 PyObject * obj0 = 0 ;
4483 char * kwnames[] = {
4484 (char *) "name", NULL
4485 };
4486
4487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) SWIG_fail;
4488 {
4489 arg1 = wxString_in_helper(obj0);
4490 if (arg1 == NULL) SWIG_fail;
4491 temp1 = true;
4492 }
4493 {
4494 PyThreadState* __tstate = wxPyBeginAllowThreads();
4495 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
4496 wxPyEndAllowThreads(__tstate);
4497 if (PyErr_Occurred()) SWIG_fail;
4498 }
4499 {
4500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4501 }
4502 {
4503 if (temp1)
4504 delete arg1;
4505 }
4506 return resultobj;
4507 fail:
4508 {
4509 if (temp1)
4510 delete arg1;
4511 }
4512 return NULL;
4513 }
4514
4515
4516 SWIGINTERN PyObject *_wrap_SystemOptions_IsFalse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4517 PyObject *resultobj = 0;
4518 wxString *arg1 = 0 ;
4519 bool result;
4520 bool temp1 = false ;
4521 PyObject * obj0 = 0 ;
4522 char * kwnames[] = {
4523 (char *) "name", NULL
4524 };
4525
4526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_IsFalse",kwnames,&obj0)) SWIG_fail;
4527 {
4528 arg1 = wxString_in_helper(obj0);
4529 if (arg1 == NULL) SWIG_fail;
4530 temp1 = true;
4531 }
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = (bool)wxSystemOptions::IsFalse((wxString const &)*arg1);
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 {
4539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4540 }
4541 {
4542 if (temp1)
4543 delete arg1;
4544 }
4545 return resultobj;
4546 fail:
4547 {
4548 if (temp1)
4549 delete arg1;
4550 }
4551 return NULL;
4552 }
4553
4554
4555 SWIGINTERN PyObject *SystemOptions_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4556 PyObject *obj;
4557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4558 SWIG_TypeNewClientData(SWIGTYPE_p_wxSystemOptions, SWIG_NewClientData(obj));
4559 return SWIG_Py_Void();
4560 }
4561
4562 SWIGINTERN PyObject *SystemOptions_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4563 return SWIG_Python_InitShadowInstance(args);
4564 }
4565
4566 SWIGINTERN int FileSelectorPromptStr_set(PyObject *) {
4567 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorPromptStr is read-only.");
4568 return 1;
4569 }
4570
4571
4572 SWIGINTERN PyObject *FileSelectorPromptStr_get(void) {
4573 PyObject *pyobj = 0;
4574
4575 {
4576 #if wxUSE_UNICODE
4577 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4578 #else
4579 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
4580 #endif
4581 }
4582 return pyobj;
4583 }
4584
4585
4586 SWIGINTERN int FileSelectorDefaultWildcardStr_set(PyObject *) {
4587 SWIG_Error(SWIG_AttributeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
4588 return 1;
4589 }
4590
4591
4592 SWIGINTERN PyObject *FileSelectorDefaultWildcardStr_get(void) {
4593 PyObject *pyobj = 0;
4594
4595 {
4596 #if wxUSE_UNICODE
4597 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4598 #else
4599 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
4600 #endif
4601 }
4602 return pyobj;
4603 }
4604
4605
4606 SWIGINTERN int DirSelectorPromptStr_set(PyObject *) {
4607 SWIG_Error(SWIG_AttributeError,"Variable DirSelectorPromptStr is read-only.");
4608 return 1;
4609 }
4610
4611
4612 SWIGINTERN PyObject *DirSelectorPromptStr_get(void) {
4613 PyObject *pyobj = 0;
4614
4615 {
4616 #if wxUSE_UNICODE
4617 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4618 #else
4619 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
4620 #endif
4621 }
4622 return pyobj;
4623 }
4624
4625
4626 SWIGINTERN PyObject *_wrap_NewId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4627 PyObject *resultobj = 0;
4628 long result;
4629
4630 if (!SWIG_Python_UnpackTuple(args,"NewId",0,0,0)) SWIG_fail;
4631 {
4632 PyThreadState* __tstate = wxPyBeginAllowThreads();
4633 result = (long)wxNewId();
4634 wxPyEndAllowThreads(__tstate);
4635 if (PyErr_Occurred()) SWIG_fail;
4636 }
4637 resultobj = SWIG_From_long(static_cast< long >(result));
4638 return resultobj;
4639 fail:
4640 return NULL;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_RegisterId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4645 PyObject *resultobj = 0;
4646 long arg1 ;
4647 long val1 ;
4648 int ecode1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 char * kwnames[] = {
4651 (char *) "id", NULL
4652 };
4653
4654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) SWIG_fail;
4655 ecode1 = SWIG_AsVal_long(obj0, &val1);
4656 if (!SWIG_IsOK(ecode1)) {
4657 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RegisterId" "', expected argument " "1"" of type '" "long""'");
4658 }
4659 arg1 = static_cast< long >(val1);
4660 {
4661 PyThreadState* __tstate = wxPyBeginAllowThreads();
4662 wxRegisterId(arg1);
4663 wxPyEndAllowThreads(__tstate);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 resultobj = SWIG_Py_Void();
4667 return resultobj;
4668 fail:
4669 return NULL;
4670 }
4671
4672
4673 SWIGINTERN PyObject *_wrap_GetCurrentId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4674 PyObject *resultobj = 0;
4675 long result;
4676
4677 if (!SWIG_Python_UnpackTuple(args,"GetCurrentId",0,0,0)) SWIG_fail;
4678 {
4679 PyThreadState* __tstate = wxPyBeginAllowThreads();
4680 result = (long)wxGetCurrentId();
4681 wxPyEndAllowThreads(__tstate);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 resultobj = SWIG_From_long(static_cast< long >(result));
4685 return resultobj;
4686 fail:
4687 return NULL;
4688 }
4689
4690
4691 SWIGINTERN PyObject *_wrap_IsStockID(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4692 PyObject *resultobj = 0;
4693 int arg1 ;
4694 bool result;
4695 int val1 ;
4696 int ecode1 = 0 ;
4697 PyObject * obj0 = 0 ;
4698 char * kwnames[] = {
4699 (char *) "id", NULL
4700 };
4701
4702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) SWIG_fail;
4703 ecode1 = SWIG_AsVal_int(obj0, &val1);
4704 if (!SWIG_IsOK(ecode1)) {
4705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockID" "', expected argument " "1"" of type '" "int""'");
4706 }
4707 arg1 = static_cast< int >(val1);
4708 {
4709 PyThreadState* __tstate = wxPyBeginAllowThreads();
4710 result = (bool)wxIsStockID(arg1);
4711 wxPyEndAllowThreads(__tstate);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 {
4715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4716 }
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 SWIGINTERN PyObject *_wrap_IsStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = 0;
4725 int arg1 ;
4726 wxString *arg2 = 0 ;
4727 bool result;
4728 int val1 ;
4729 int ecode1 = 0 ;
4730 bool temp2 = false ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 char * kwnames[] = {
4734 (char *) "id",(char *) "label", NULL
4735 };
4736
4737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) SWIG_fail;
4738 ecode1 = SWIG_AsVal_int(obj0, &val1);
4739 if (!SWIG_IsOK(ecode1)) {
4740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsStockLabel" "', expected argument " "1"" of type '" "int""'");
4741 }
4742 arg1 = static_cast< int >(val1);
4743 {
4744 arg2 = wxString_in_helper(obj1);
4745 if (arg2 == NULL) SWIG_fail;
4746 temp2 = true;
4747 }
4748 {
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
4751 wxPyEndAllowThreads(__tstate);
4752 if (PyErr_Occurred()) SWIG_fail;
4753 }
4754 {
4755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4756 }
4757 {
4758 if (temp2)
4759 delete arg2;
4760 }
4761 return resultobj;
4762 fail:
4763 {
4764 if (temp2)
4765 delete arg2;
4766 }
4767 return NULL;
4768 }
4769
4770
4771 SWIGINTERN PyObject *_wrap_GetStockLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4772 PyObject *resultobj = 0;
4773 int arg1 ;
4774 bool arg2 = (bool) true ;
4775 wxString arg3 = (wxString) wxPyEmptyString ;
4776 wxString result;
4777 int val1 ;
4778 int ecode1 = 0 ;
4779 bool val2 ;
4780 int ecode2 = 0 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 PyObject * obj2 = 0 ;
4784 char * kwnames[] = {
4785 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
4786 };
4787
4788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4789 ecode1 = SWIG_AsVal_int(obj0, &val1);
4790 if (!SWIG_IsOK(ecode1)) {
4791 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetStockLabel" "', expected argument " "1"" of type '" "int""'");
4792 }
4793 arg1 = static_cast< int >(val1);
4794 if (obj1) {
4795 ecode2 = SWIG_AsVal_bool(obj1, &val2);
4796 if (!SWIG_IsOK(ecode2)) {
4797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetStockLabel" "', expected argument " "2"" of type '" "bool""'");
4798 }
4799 arg2 = static_cast< bool >(val2);
4800 }
4801 if (obj2) {
4802 {
4803 wxString* sptr = wxString_in_helper(obj2);
4804 if (sptr == NULL) SWIG_fail;
4805 arg3 = *sptr;
4806 delete sptr;
4807 }
4808 }
4809 {
4810 PyThreadState* __tstate = wxPyBeginAllowThreads();
4811 result = wxGetStockLabel(arg1,arg2,arg3);
4812 wxPyEndAllowThreads(__tstate);
4813 if (PyErr_Occurred()) SWIG_fail;
4814 }
4815 {
4816 #if wxUSE_UNICODE
4817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4818 #else
4819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4820 #endif
4821 }
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 SWIGINTERN PyObject *_wrap_Bell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4829 PyObject *resultobj = 0;
4830
4831 if (!SWIG_Python_UnpackTuple(args,"Bell",0,0,0)) SWIG_fail;
4832 {
4833 if (!wxPyCheckForApp()) SWIG_fail;
4834 PyThreadState* __tstate = wxPyBeginAllowThreads();
4835 wxBell();
4836 wxPyEndAllowThreads(__tstate);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 resultobj = SWIG_Py_Void();
4840 return resultobj;
4841 fail:
4842 return NULL;
4843 }
4844
4845
4846 SWIGINTERN PyObject *_wrap_EndBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4847 PyObject *resultobj = 0;
4848
4849 if (!SWIG_Python_UnpackTuple(args,"EndBusyCursor",0,0,0)) SWIG_fail;
4850 {
4851 if (!wxPyCheckForApp()) SWIG_fail;
4852 PyThreadState* __tstate = wxPyBeginAllowThreads();
4853 wxEndBusyCursor();
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_Py_Void();
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 SWIGINTERN PyObject *_wrap_GetElapsedTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj = 0;
4866 bool arg1 = (bool) true ;
4867 long result;
4868 bool val1 ;
4869 int ecode1 = 0 ;
4870 PyObject * obj0 = 0 ;
4871 char * kwnames[] = {
4872 (char *) "resetTimer", NULL
4873 };
4874
4875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) SWIG_fail;
4876 if (obj0) {
4877 ecode1 = SWIG_AsVal_bool(obj0, &val1);
4878 if (!SWIG_IsOK(ecode1)) {
4879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetElapsedTime" "', expected argument " "1"" of type '" "bool""'");
4880 }
4881 arg1 = static_cast< bool >(val1);
4882 }
4883 {
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 result = (long)wxGetElapsedTime(arg1);
4886 wxPyEndAllowThreads(__tstate);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_From_long(static_cast< long >(result));
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_IsBusy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4897 PyObject *resultobj = 0;
4898 bool result;
4899
4900 if (!SWIG_Python_UnpackTuple(args,"IsBusy",0,0,0)) SWIG_fail;
4901 {
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 result = (bool)wxIsBusy();
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 {
4908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4909 }
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4917 PyObject *resultobj = 0;
4918 wxString result;
4919
4920 if (!SWIG_Python_UnpackTuple(args,"Now",0,0,0)) SWIG_fail;
4921 {
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 result = wxNow();
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 {
4928 #if wxUSE_UNICODE
4929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4930 #else
4931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4932 #endif
4933 }
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_Shell(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj = 0;
4942 wxString const &arg1_defvalue = wxPyEmptyString ;
4943 wxString *arg1 = (wxString *) &arg1_defvalue ;
4944 bool result;
4945 bool temp1 = false ;
4946 PyObject * obj0 = 0 ;
4947 char * kwnames[] = {
4948 (char *) "command", NULL
4949 };
4950
4951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) SWIG_fail;
4952 if (obj0) {
4953 {
4954 arg1 = wxString_in_helper(obj0);
4955 if (arg1 == NULL) SWIG_fail;
4956 temp1 = true;
4957 }
4958 }
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 result = (bool)wxShell((wxString const &)*arg1);
4962 wxPyEndAllowThreads(__tstate);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 {
4966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4967 }
4968 {
4969 if (temp1)
4970 delete arg1;
4971 }
4972 return resultobj;
4973 fail:
4974 {
4975 if (temp1)
4976 delete arg1;
4977 }
4978 return NULL;
4979 }
4980
4981
4982 SWIGINTERN PyObject *_wrap_StartTimer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4983 PyObject *resultobj = 0;
4984
4985 if (!SWIG_Python_UnpackTuple(args,"StartTimer",0,0,0)) SWIG_fail;
4986 {
4987 PyThreadState* __tstate = wxPyBeginAllowThreads();
4988 wxStartTimer();
4989 wxPyEndAllowThreads(__tstate);
4990 if (PyErr_Occurred()) SWIG_fail;
4991 }
4992 resultobj = SWIG_Py_Void();
4993 return resultobj;
4994 fail:
4995 return NULL;
4996 }
4997
4998
4999 SWIGINTERN PyObject *_wrap_GetOsVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5000 PyObject *resultobj = 0;
5001 int *arg1 = (int *) 0 ;
5002 int *arg2 = (int *) 0 ;
5003 int result;
5004 int temp1 ;
5005 int res1 = SWIG_TMPOBJ ;
5006 int temp2 ;
5007 int res2 = SWIG_TMPOBJ ;
5008
5009 arg1 = &temp1;
5010 arg2 = &temp2;
5011 if (!SWIG_Python_UnpackTuple(args,"GetOsVersion",0,0,0)) SWIG_fail;
5012 {
5013 PyThreadState* __tstate = wxPyBeginAllowThreads();
5014 result = (int)wxGetOsVersion(arg1,arg2);
5015 wxPyEndAllowThreads(__tstate);
5016 if (PyErr_Occurred()) SWIG_fail;
5017 }
5018 resultobj = SWIG_From_int(static_cast< int >(result));
5019 if (SWIG_IsTmpObj(res1)) {
5020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
5021 } else {
5022 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5023 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
5024 }
5025 if (SWIG_IsTmpObj(res2)) {
5026 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
5027 } else {
5028 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
5029 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
5030 }
5031 return resultobj;
5032 fail:
5033 return NULL;
5034 }
5035
5036
5037 SWIGINTERN PyObject *_wrap_GetOsDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5038 PyObject *resultobj = 0;
5039 wxString result;
5040
5041 if (!SWIG_Python_UnpackTuple(args,"GetOsDescription",0,0,0)) SWIG_fail;
5042 {
5043 PyThreadState* __tstate = wxPyBeginAllowThreads();
5044 result = wxGetOsDescription();
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 {
5049 #if wxUSE_UNICODE
5050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5051 #else
5052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5053 #endif
5054 }
5055 return resultobj;
5056 fail:
5057 return NULL;
5058 }
5059
5060
5061 SWIGINTERN PyObject *_wrap_GetFreeMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5062 PyObject *resultobj = 0;
5063 wxMemorySize result;
5064
5065 if (!SWIG_Python_UnpackTuple(args,"GetFreeMemory",0,0,0)) SWIG_fail;
5066 {
5067 PyThreadState* __tstate = wxPyBeginAllowThreads();
5068 result = wxGetFreeMemory();
5069 wxPyEndAllowThreads(__tstate);
5070 if (PyErr_Occurred()) SWIG_fail;
5071 }
5072 resultobj = SWIG_NewPointerObj((new wxMemorySize(static_cast< const wxMemorySize& >(result))), SWIGTYPE_p_wxMemorySize, SWIG_POINTER_OWN | 0 );
5073 return resultobj;
5074 fail:
5075 return NULL;
5076 }
5077
5078
5079 SWIGINTERN PyObject *_wrap_Shutdown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5080 PyObject *resultobj = 0;
5081 wxShutdownFlags arg1 ;
5082 bool result;
5083 int val1 ;
5084 int ecode1 = 0 ;
5085 PyObject * obj0 = 0 ;
5086 char * kwnames[] = {
5087 (char *) "wFlags", NULL
5088 };
5089
5090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) SWIG_fail;
5091 ecode1 = SWIG_AsVal_int(obj0, &val1);
5092 if (!SWIG_IsOK(ecode1)) {
5093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Shutdown" "', expected argument " "1"" of type '" "wxShutdownFlags""'");
5094 }
5095 arg1 = static_cast< wxShutdownFlags >(val1);
5096 {
5097 if (!wxPyCheckForApp()) SWIG_fail;
5098 PyThreadState* __tstate = wxPyBeginAllowThreads();
5099 result = (bool)wxShutdown(arg1);
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 {
5104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5105 }
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *_wrap_Sleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5113 PyObject *resultobj = 0;
5114 int arg1 ;
5115 int val1 ;
5116 int ecode1 = 0 ;
5117 PyObject * obj0 = 0 ;
5118 char * kwnames[] = {
5119 (char *) "secs", NULL
5120 };
5121
5122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) SWIG_fail;
5123 ecode1 = SWIG_AsVal_int(obj0, &val1);
5124 if (!SWIG_IsOK(ecode1)) {
5125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Sleep" "', expected argument " "1"" of type '" "int""'");
5126 }
5127 arg1 = static_cast< int >(val1);
5128 {
5129 PyThreadState* __tstate = wxPyBeginAllowThreads();
5130 wxSleep(arg1);
5131 wxPyEndAllowThreads(__tstate);
5132 if (PyErr_Occurred()) SWIG_fail;
5133 }
5134 resultobj = SWIG_Py_Void();
5135 return resultobj;
5136 fail:
5137 return NULL;
5138 }
5139
5140
5141 SWIGINTERN PyObject *_wrap_MilliSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5142 PyObject *resultobj = 0;
5143 unsigned long arg1 ;
5144 unsigned long val1 ;
5145 int ecode1 = 0 ;
5146 PyObject * obj0 = 0 ;
5147 char * kwnames[] = {
5148 (char *) "milliseconds", NULL
5149 };
5150
5151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) SWIG_fail;
5152 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5153 if (!SWIG_IsOK(ecode1)) {
5154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MilliSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5155 }
5156 arg1 = static_cast< unsigned long >(val1);
5157 {
5158 PyThreadState* __tstate = wxPyBeginAllowThreads();
5159 wxMilliSleep(arg1);
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 resultobj = SWIG_Py_Void();
5164 return resultobj;
5165 fail:
5166 return NULL;
5167 }
5168
5169
5170 SWIGINTERN PyObject *_wrap_MicroSleep(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5171 PyObject *resultobj = 0;
5172 unsigned long arg1 ;
5173 unsigned long val1 ;
5174 int ecode1 = 0 ;
5175 PyObject * obj0 = 0 ;
5176 char * kwnames[] = {
5177 (char *) "microseconds", NULL
5178 };
5179
5180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) SWIG_fail;
5181 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5182 if (!SWIG_IsOK(ecode1)) {
5183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MicroSleep" "', expected argument " "1"" of type '" "unsigned long""'");
5184 }
5185 arg1 = static_cast< unsigned long >(val1);
5186 {
5187 PyThreadState* __tstate = wxPyBeginAllowThreads();
5188 wxMicroSleep(arg1);
5189 wxPyEndAllowThreads(__tstate);
5190 if (PyErr_Occurred()) SWIG_fail;
5191 }
5192 resultobj = SWIG_Py_Void();
5193 return resultobj;
5194 fail:
5195 return NULL;
5196 }
5197
5198
5199 SWIGINTERN PyObject *_wrap_EnableTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5200 PyObject *resultobj = 0;
5201 bool arg1 ;
5202 bool val1 ;
5203 int ecode1 = 0 ;
5204 PyObject * obj0 = 0 ;
5205 char * kwnames[] = {
5206 (char *) "enable", NULL
5207 };
5208
5209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) SWIG_fail;
5210 ecode1 = SWIG_AsVal_bool(obj0, &val1);
5211 if (!SWIG_IsOK(ecode1)) {
5212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "EnableTopLevelWindows" "', expected argument " "1"" of type '" "bool""'");
5213 }
5214 arg1 = static_cast< bool >(val1);
5215 {
5216 PyThreadState* __tstate = wxPyBeginAllowThreads();
5217 wxEnableTopLevelWindows(arg1);
5218 wxPyEndAllowThreads(__tstate);
5219 if (PyErr_Occurred()) SWIG_fail;
5220 }
5221 resultobj = SWIG_Py_Void();
5222 return resultobj;
5223 fail:
5224 return NULL;
5225 }
5226
5227
5228 SWIGINTERN PyObject *_wrap_StripMenuCodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5229 PyObject *resultobj = 0;
5230 wxString *arg1 = 0 ;
5231 wxString result;
5232 bool temp1 = false ;
5233 PyObject * obj0 = 0 ;
5234 char * kwnames[] = {
5235 (char *) "_in", NULL
5236 };
5237
5238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) SWIG_fail;
5239 {
5240 arg1 = wxString_in_helper(obj0);
5241 if (arg1 == NULL) SWIG_fail;
5242 temp1 = true;
5243 }
5244 {
5245 PyThreadState* __tstate = wxPyBeginAllowThreads();
5246 result = wxStripMenuCodes((wxString const &)*arg1);
5247 wxPyEndAllowThreads(__tstate);
5248 if (PyErr_Occurred()) SWIG_fail;
5249 }
5250 {
5251 #if wxUSE_UNICODE
5252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5253 #else
5254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5255 #endif
5256 }
5257 {
5258 if (temp1)
5259 delete arg1;
5260 }
5261 return resultobj;
5262 fail:
5263 {
5264 if (temp1)
5265 delete arg1;
5266 }
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_GetEmailAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5272 PyObject *resultobj = 0;
5273 wxString result;
5274
5275 if (!SWIG_Python_UnpackTuple(args,"GetEmailAddress",0,0,0)) SWIG_fail;
5276 {
5277 PyThreadState* __tstate = wxPyBeginAllowThreads();
5278 result = wxGetEmailAddress();
5279 wxPyEndAllowThreads(__tstate);
5280 if (PyErr_Occurred()) SWIG_fail;
5281 }
5282 {
5283 #if wxUSE_UNICODE
5284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5285 #else
5286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5287 #endif
5288 }
5289 return resultobj;
5290 fail:
5291 return NULL;
5292 }
5293
5294
5295 SWIGINTERN PyObject *_wrap_GetHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5296 PyObject *resultobj = 0;
5297 wxString result;
5298
5299 if (!SWIG_Python_UnpackTuple(args,"GetHostName",0,0,0)) SWIG_fail;
5300 {
5301 PyThreadState* __tstate = wxPyBeginAllowThreads();
5302 result = wxGetHostName();
5303 wxPyEndAllowThreads(__tstate);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 {
5307 #if wxUSE_UNICODE
5308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5309 #else
5310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5311 #endif
5312 }
5313 return resultobj;
5314 fail:
5315 return NULL;
5316 }
5317
5318
5319 SWIGINTERN PyObject *_wrap_GetFullHostName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5320 PyObject *resultobj = 0;
5321 wxString result;
5322
5323 if (!SWIG_Python_UnpackTuple(args,"GetFullHostName",0,0,0)) SWIG_fail;
5324 {
5325 PyThreadState* __tstate = wxPyBeginAllowThreads();
5326 result = wxGetFullHostName();
5327 wxPyEndAllowThreads(__tstate);
5328 if (PyErr_Occurred()) SWIG_fail;
5329 }
5330 {
5331 #if wxUSE_UNICODE
5332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5333 #else
5334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5335 #endif
5336 }
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_GetUserId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5344 PyObject *resultobj = 0;
5345 wxString result;
5346
5347 if (!SWIG_Python_UnpackTuple(args,"GetUserId",0,0,0)) SWIG_fail;
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 result = wxGetUserId();
5351 wxPyEndAllowThreads(__tstate);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 #if wxUSE_UNICODE
5356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5357 #else
5358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5359 #endif
5360 }
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 SWIGINTERN PyObject *_wrap_GetUserName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5368 PyObject *resultobj = 0;
5369 wxString result;
5370
5371 if (!SWIG_Python_UnpackTuple(args,"GetUserName",0,0,0)) SWIG_fail;
5372 {
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = wxGetUserName();
5375 wxPyEndAllowThreads(__tstate);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 {
5379 #if wxUSE_UNICODE
5380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5381 #else
5382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5383 #endif
5384 }
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_GetHomeDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5392 PyObject *resultobj = 0;
5393 wxString result;
5394
5395 if (!SWIG_Python_UnpackTuple(args,"GetHomeDir",0,0,0)) SWIG_fail;
5396 {
5397 PyThreadState* __tstate = wxPyBeginAllowThreads();
5398 result = wxGetHomeDir();
5399 wxPyEndAllowThreads(__tstate);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 {
5403 #if wxUSE_UNICODE
5404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5405 #else
5406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5407 #endif
5408 }
5409 return resultobj;
5410 fail:
5411 return NULL;
5412 }
5413
5414
5415 SWIGINTERN PyObject *_wrap_GetUserHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5416 PyObject *resultobj = 0;
5417 wxString const &arg1_defvalue = wxPyEmptyString ;
5418 wxString *arg1 = (wxString *) &arg1_defvalue ;
5419 wxString result;
5420 bool temp1 = false ;
5421 PyObject * obj0 = 0 ;
5422 char * kwnames[] = {
5423 (char *) "user", NULL
5424 };
5425
5426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) SWIG_fail;
5427 if (obj0) {
5428 {
5429 arg1 = wxString_in_helper(obj0);
5430 if (arg1 == NULL) SWIG_fail;
5431 temp1 = true;
5432 }
5433 }
5434 {
5435 PyThreadState* __tstate = wxPyBeginAllowThreads();
5436 result = wxGetUserHome((wxString const &)*arg1);
5437 wxPyEndAllowThreads(__tstate);
5438 if (PyErr_Occurred()) SWIG_fail;
5439 }
5440 {
5441 #if wxUSE_UNICODE
5442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5443 #else
5444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5445 #endif
5446 }
5447 {
5448 if (temp1)
5449 delete arg1;
5450 }
5451 return resultobj;
5452 fail:
5453 {
5454 if (temp1)
5455 delete arg1;
5456 }
5457 return NULL;
5458 }
5459
5460
5461 SWIGINTERN PyObject *_wrap_GetProcessId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5462 PyObject *resultobj = 0;
5463 unsigned long result;
5464
5465 if (!SWIG_Python_UnpackTuple(args,"GetProcessId",0,0,0)) SWIG_fail;
5466 {
5467 PyThreadState* __tstate = wxPyBeginAllowThreads();
5468 result = (unsigned long)wxGetProcessId();
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
5473 return resultobj;
5474 fail:
5475 return NULL;
5476 }
5477
5478
5479 SWIGINTERN PyObject *_wrap_Trap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5480 PyObject *resultobj = 0;
5481
5482 if (!SWIG_Python_UnpackTuple(args,"Trap",0,0,0)) SWIG_fail;
5483 {
5484 PyThreadState* __tstate = wxPyBeginAllowThreads();
5485 wxTrap();
5486 wxPyEndAllowThreads(__tstate);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 resultobj = SWIG_Py_Void();
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_FileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5497 PyObject *resultobj = 0;
5498 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
5499 wxString *arg1 = (wxString *) &arg1_defvalue ;
5500 wxString const &arg2_defvalue = wxPyEmptyString ;
5501 wxString *arg2 = (wxString *) &arg2_defvalue ;
5502 wxString const &arg3_defvalue = wxPyEmptyString ;
5503 wxString *arg3 = (wxString *) &arg3_defvalue ;
5504 wxString const &arg4_defvalue = wxPyEmptyString ;
5505 wxString *arg4 = (wxString *) &arg4_defvalue ;
5506 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
5507 wxString *arg5 = (wxString *) &arg5_defvalue ;
5508 int arg6 = (int) 0 ;
5509 wxWindow *arg7 = (wxWindow *) NULL ;
5510 int arg8 = (int) -1 ;
5511 int arg9 = (int) -1 ;
5512 wxString result;
5513 bool temp1 = false ;
5514 bool temp2 = false ;
5515 bool temp3 = false ;
5516 bool temp4 = false ;
5517 bool temp5 = false ;
5518 int val6 ;
5519 int ecode6 = 0 ;
5520 void *argp7 = 0 ;
5521 int res7 = 0 ;
5522 int val8 ;
5523 int ecode8 = 0 ;
5524 int val9 ;
5525 int ecode9 = 0 ;
5526 PyObject * obj0 = 0 ;
5527 PyObject * obj1 = 0 ;
5528 PyObject * obj2 = 0 ;
5529 PyObject * obj3 = 0 ;
5530 PyObject * obj4 = 0 ;
5531 PyObject * obj5 = 0 ;
5532 PyObject * obj6 = 0 ;
5533 PyObject * obj7 = 0 ;
5534 PyObject * obj8 = 0 ;
5535 char * kwnames[] = {
5536 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
5537 };
5538
5539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5540 if (obj0) {
5541 {
5542 arg1 = wxString_in_helper(obj0);
5543 if (arg1 == NULL) SWIG_fail;
5544 temp1 = true;
5545 }
5546 }
5547 if (obj1) {
5548 {
5549 arg2 = wxString_in_helper(obj1);
5550 if (arg2 == NULL) SWIG_fail;
5551 temp2 = true;
5552 }
5553 }
5554 if (obj2) {
5555 {
5556 arg3 = wxString_in_helper(obj2);
5557 if (arg3 == NULL) SWIG_fail;
5558 temp3 = true;
5559 }
5560 }
5561 if (obj3) {
5562 {
5563 arg4 = wxString_in_helper(obj3);
5564 if (arg4 == NULL) SWIG_fail;
5565 temp4 = true;
5566 }
5567 }
5568 if (obj4) {
5569 {
5570 arg5 = wxString_in_helper(obj4);
5571 if (arg5 == NULL) SWIG_fail;
5572 temp5 = true;
5573 }
5574 }
5575 if (obj5) {
5576 ecode6 = SWIG_AsVal_int(obj5, &val6);
5577 if (!SWIG_IsOK(ecode6)) {
5578 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FileSelector" "', expected argument " "6"" of type '" "int""'");
5579 }
5580 arg6 = static_cast< int >(val6);
5581 }
5582 if (obj6) {
5583 res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_wxWindow, 0 | 0 );
5584 if (!SWIG_IsOK(res7)) {
5585 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FileSelector" "', expected argument " "7"" of type '" "wxWindow *""'");
5586 }
5587 arg7 = reinterpret_cast< wxWindow * >(argp7);
5588 }
5589 if (obj7) {
5590 ecode8 = SWIG_AsVal_int(obj7, &val8);
5591 if (!SWIG_IsOK(ecode8)) {
5592 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FileSelector" "', expected argument " "8"" of type '" "int""'");
5593 }
5594 arg8 = static_cast< int >(val8);
5595 }
5596 if (obj8) {
5597 ecode9 = SWIG_AsVal_int(obj8, &val9);
5598 if (!SWIG_IsOK(ecode9)) {
5599 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FileSelector" "', expected argument " "9"" of type '" "int""'");
5600 }
5601 arg9 = static_cast< int >(val9);
5602 }
5603 {
5604 if (!wxPyCheckForApp()) SWIG_fail;
5605 PyThreadState* __tstate = wxPyBeginAllowThreads();
5606 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
5607 wxPyEndAllowThreads(__tstate);
5608 if (PyErr_Occurred()) SWIG_fail;
5609 }
5610 {
5611 #if wxUSE_UNICODE
5612 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5613 #else
5614 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5615 #endif
5616 }
5617 {
5618 if (temp1)
5619 delete arg1;
5620 }
5621 {
5622 if (temp2)
5623 delete arg2;
5624 }
5625 {
5626 if (temp3)
5627 delete arg3;
5628 }
5629 {
5630 if (temp4)
5631 delete arg4;
5632 }
5633 {
5634 if (temp5)
5635 delete arg5;
5636 }
5637 return resultobj;
5638 fail:
5639 {
5640 if (temp1)
5641 delete arg1;
5642 }
5643 {
5644 if (temp2)
5645 delete arg2;
5646 }
5647 {
5648 if (temp3)
5649 delete arg3;
5650 }
5651 {
5652 if (temp4)
5653 delete arg4;
5654 }
5655 {
5656 if (temp5)
5657 delete arg5;
5658 }
5659 return NULL;
5660 }
5661
5662
5663 SWIGINTERN PyObject *_wrap_LoadFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5664 PyObject *resultobj = 0;
5665 wxString *arg1 = 0 ;
5666 wxString *arg2 = 0 ;
5667 wxString const &arg3_defvalue = wxPyEmptyString ;
5668 wxString *arg3 = (wxString *) &arg3_defvalue ;
5669 wxWindow *arg4 = (wxWindow *) NULL ;
5670 wxString result;
5671 bool temp1 = false ;
5672 bool temp2 = false ;
5673 bool temp3 = false ;
5674 void *argp4 = 0 ;
5675 int res4 = 0 ;
5676 PyObject * obj0 = 0 ;
5677 PyObject * obj1 = 0 ;
5678 PyObject * obj2 = 0 ;
5679 PyObject * obj3 = 0 ;
5680 char * kwnames[] = {
5681 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5682 };
5683
5684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5685 {
5686 arg1 = wxString_in_helper(obj0);
5687 if (arg1 == NULL) SWIG_fail;
5688 temp1 = true;
5689 }
5690 {
5691 arg2 = wxString_in_helper(obj1);
5692 if (arg2 == NULL) SWIG_fail;
5693 temp2 = true;
5694 }
5695 if (obj2) {
5696 {
5697 arg3 = wxString_in_helper(obj2);
5698 if (arg3 == NULL) SWIG_fail;
5699 temp3 = true;
5700 }
5701 }
5702 if (obj3) {
5703 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5704 if (!SWIG_IsOK(res4)) {
5705 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LoadFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5706 }
5707 arg4 = reinterpret_cast< wxWindow * >(argp4);
5708 }
5709 {
5710 if (!wxPyCheckForApp()) SWIG_fail;
5711 PyThreadState* __tstate = wxPyBeginAllowThreads();
5712 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5713 wxPyEndAllowThreads(__tstate);
5714 if (PyErr_Occurred()) SWIG_fail;
5715 }
5716 {
5717 #if wxUSE_UNICODE
5718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5719 #else
5720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5721 #endif
5722 }
5723 {
5724 if (temp1)
5725 delete arg1;
5726 }
5727 {
5728 if (temp2)
5729 delete arg2;
5730 }
5731 {
5732 if (temp3)
5733 delete arg3;
5734 }
5735 return resultobj;
5736 fail:
5737 {
5738 if (temp1)
5739 delete arg1;
5740 }
5741 {
5742 if (temp2)
5743 delete arg2;
5744 }
5745 {
5746 if (temp3)
5747 delete arg3;
5748 }
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_SaveFileSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5754 PyObject *resultobj = 0;
5755 wxString *arg1 = 0 ;
5756 wxString *arg2 = 0 ;
5757 wxString const &arg3_defvalue = wxPyEmptyString ;
5758 wxString *arg3 = (wxString *) &arg3_defvalue ;
5759 wxWindow *arg4 = (wxWindow *) NULL ;
5760 wxString result;
5761 bool temp1 = false ;
5762 bool temp2 = false ;
5763 bool temp3 = false ;
5764 void *argp4 = 0 ;
5765 int res4 = 0 ;
5766 PyObject * obj0 = 0 ;
5767 PyObject * obj1 = 0 ;
5768 PyObject * obj2 = 0 ;
5769 PyObject * obj3 = 0 ;
5770 char * kwnames[] = {
5771 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
5772 };
5773
5774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5775 {
5776 arg1 = wxString_in_helper(obj0);
5777 if (arg1 == NULL) SWIG_fail;
5778 temp1 = true;
5779 }
5780 {
5781 arg2 = wxString_in_helper(obj1);
5782 if (arg2 == NULL) SWIG_fail;
5783 temp2 = true;
5784 }
5785 if (obj2) {
5786 {
5787 arg3 = wxString_in_helper(obj2);
5788 if (arg3 == NULL) SWIG_fail;
5789 temp3 = true;
5790 }
5791 }
5792 if (obj3) {
5793 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5794 if (!SWIG_IsOK(res4)) {
5795 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SaveFileSelector" "', expected argument " "4"" of type '" "wxWindow *""'");
5796 }
5797 arg4 = reinterpret_cast< wxWindow * >(argp4);
5798 }
5799 {
5800 if (!wxPyCheckForApp()) SWIG_fail;
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5803 wxPyEndAllowThreads(__tstate);
5804 if (PyErr_Occurred()) SWIG_fail;
5805 }
5806 {
5807 #if wxUSE_UNICODE
5808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5809 #else
5810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5811 #endif
5812 }
5813 {
5814 if (temp1)
5815 delete arg1;
5816 }
5817 {
5818 if (temp2)
5819 delete arg2;
5820 }
5821 {
5822 if (temp3)
5823 delete arg3;
5824 }
5825 return resultobj;
5826 fail:
5827 {
5828 if (temp1)
5829 delete arg1;
5830 }
5831 {
5832 if (temp2)
5833 delete arg2;
5834 }
5835 {
5836 if (temp3)
5837 delete arg3;
5838 }
5839 return NULL;
5840 }
5841
5842
5843 SWIGINTERN PyObject *_wrap_DirSelector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj = 0;
5845 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
5846 wxString *arg1 = (wxString *) &arg1_defvalue ;
5847 wxString const &arg2_defvalue = wxPyEmptyString ;
5848 wxString *arg2 = (wxString *) &arg2_defvalue ;
5849 long arg3 = (long) wxDD_DEFAULT_STYLE ;
5850 wxPoint const &arg4_defvalue = wxDefaultPosition ;
5851 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
5852 wxWindow *arg5 = (wxWindow *) NULL ;
5853 wxString result;
5854 bool temp1 = false ;
5855 bool temp2 = false ;
5856 long val3 ;
5857 int ecode3 = 0 ;
5858 wxPoint temp4 ;
5859 void *argp5 = 0 ;
5860 int res5 = 0 ;
5861 PyObject * obj0 = 0 ;
5862 PyObject * obj1 = 0 ;
5863 PyObject * obj2 = 0 ;
5864 PyObject * obj3 = 0 ;
5865 PyObject * obj4 = 0 ;
5866 char * kwnames[] = {
5867 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
5868 };
5869
5870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5871 if (obj0) {
5872 {
5873 arg1 = wxString_in_helper(obj0);
5874 if (arg1 == NULL) SWIG_fail;
5875 temp1 = true;
5876 }
5877 }
5878 if (obj1) {
5879 {
5880 arg2 = wxString_in_helper(obj1);
5881 if (arg2 == NULL) SWIG_fail;
5882 temp2 = true;
5883 }
5884 }
5885 if (obj2) {
5886 ecode3 = SWIG_AsVal_long(obj2, &val3);
5887 if (!SWIG_IsOK(ecode3)) {
5888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DirSelector" "', expected argument " "3"" of type '" "long""'");
5889 }
5890 arg3 = static_cast< long >(val3);
5891 }
5892 if (obj3) {
5893 {
5894 arg4 = &temp4;
5895 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
5896 }
5897 }
5898 if (obj4) {
5899 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
5900 if (!SWIG_IsOK(res5)) {
5901 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DirSelector" "', expected argument " "5"" of type '" "wxWindow *""'");
5902 }
5903 arg5 = reinterpret_cast< wxWindow * >(argp5);
5904 }
5905 {
5906 if (!wxPyCheckForApp()) SWIG_fail;
5907 PyThreadState* __tstate = wxPyBeginAllowThreads();
5908 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
5909 wxPyEndAllowThreads(__tstate);
5910 if (PyErr_Occurred()) SWIG_fail;
5911 }
5912 {
5913 #if wxUSE_UNICODE
5914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5915 #else
5916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5917 #endif
5918 }
5919 {
5920 if (temp1)
5921 delete arg1;
5922 }
5923 {
5924 if (temp2)
5925 delete arg2;
5926 }
5927 return resultobj;
5928 fail:
5929 {
5930 if (temp1)
5931 delete arg1;
5932 }
5933 {
5934 if (temp2)
5935 delete arg2;
5936 }
5937 return NULL;
5938 }
5939
5940
5941 SWIGINTERN PyObject *_wrap_GetTextFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5942 PyObject *resultobj = 0;
5943 wxString *arg1 = 0 ;
5944 wxString const &arg2_defvalue = wxPyEmptyString ;
5945 wxString *arg2 = (wxString *) &arg2_defvalue ;
5946 wxString const &arg3_defvalue = wxPyEmptyString ;
5947 wxString *arg3 = (wxString *) &arg3_defvalue ;
5948 wxWindow *arg4 = (wxWindow *) NULL ;
5949 int arg5 = (int) -1 ;
5950 int arg6 = (int) -1 ;
5951 bool arg7 = (bool) true ;
5952 wxString result;
5953 bool temp1 = false ;
5954 bool temp2 = false ;
5955 bool temp3 = false ;
5956 void *argp4 = 0 ;
5957 int res4 = 0 ;
5958 int val5 ;
5959 int ecode5 = 0 ;
5960 int val6 ;
5961 int ecode6 = 0 ;
5962 bool val7 ;
5963 int ecode7 = 0 ;
5964 PyObject * obj0 = 0 ;
5965 PyObject * obj1 = 0 ;
5966 PyObject * obj2 = 0 ;
5967 PyObject * obj3 = 0 ;
5968 PyObject * obj4 = 0 ;
5969 PyObject * obj5 = 0 ;
5970 PyObject * obj6 = 0 ;
5971 char * kwnames[] = {
5972 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
5973 };
5974
5975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5976 {
5977 arg1 = wxString_in_helper(obj0);
5978 if (arg1 == NULL) SWIG_fail;
5979 temp1 = true;
5980 }
5981 if (obj1) {
5982 {
5983 arg2 = wxString_in_helper(obj1);
5984 if (arg2 == NULL) SWIG_fail;
5985 temp2 = true;
5986 }
5987 }
5988 if (obj2) {
5989 {
5990 arg3 = wxString_in_helper(obj2);
5991 if (arg3 == NULL) SWIG_fail;
5992 temp3 = true;
5993 }
5994 }
5995 if (obj3) {
5996 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
5997 if (!SWIG_IsOK(res4)) {
5998 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetTextFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
5999 }
6000 arg4 = reinterpret_cast< wxWindow * >(argp4);
6001 }
6002 if (obj4) {
6003 ecode5 = SWIG_AsVal_int(obj4, &val5);
6004 if (!SWIG_IsOK(ecode5)) {
6005 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GetTextFromUser" "', expected argument " "5"" of type '" "int""'");
6006 }
6007 arg5 = static_cast< int >(val5);
6008 }
6009 if (obj5) {
6010 ecode6 = SWIG_AsVal_int(obj5, &val6);
6011 if (!SWIG_IsOK(ecode6)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetTextFromUser" "', expected argument " "6"" of type '" "int""'");
6013 }
6014 arg6 = static_cast< int >(val6);
6015 }
6016 if (obj6) {
6017 ecode7 = SWIG_AsVal_bool(obj6, &val7);
6018 if (!SWIG_IsOK(ecode7)) {
6019 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetTextFromUser" "', expected argument " "7"" of type '" "bool""'");
6020 }
6021 arg7 = static_cast< bool >(val7);
6022 }
6023 {
6024 if (!wxPyCheckForApp()) SWIG_fail;
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
6027 wxPyEndAllowThreads(__tstate);
6028 if (PyErr_Occurred()) SWIG_fail;
6029 }
6030 {
6031 #if wxUSE_UNICODE
6032 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6033 #else
6034 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6035 #endif
6036 }
6037 {
6038 if (temp1)
6039 delete arg1;
6040 }
6041 {
6042 if (temp2)
6043 delete arg2;
6044 }
6045 {
6046 if (temp3)
6047 delete arg3;
6048 }
6049 return resultobj;
6050 fail:
6051 {
6052 if (temp1)
6053 delete arg1;
6054 }
6055 {
6056 if (temp2)
6057 delete arg2;
6058 }
6059 {
6060 if (temp3)
6061 delete arg3;
6062 }
6063 return NULL;
6064 }
6065
6066
6067 SWIGINTERN PyObject *_wrap_GetPasswordFromUser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6068 PyObject *resultobj = 0;
6069 wxString *arg1 = 0 ;
6070 wxString const &arg2_defvalue = wxPyEmptyString ;
6071 wxString *arg2 = (wxString *) &arg2_defvalue ;
6072 wxString const &arg3_defvalue = wxPyEmptyString ;
6073 wxString *arg3 = (wxString *) &arg3_defvalue ;
6074 wxWindow *arg4 = (wxWindow *) NULL ;
6075 wxString result;
6076 bool temp1 = false ;
6077 bool temp2 = false ;
6078 bool temp3 = false ;
6079 void *argp4 = 0 ;
6080 int res4 = 0 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 PyObject * obj2 = 0 ;
6084 PyObject * obj3 = 0 ;
6085 char * kwnames[] = {
6086 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
6087 };
6088
6089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6090 {
6091 arg1 = wxString_in_helper(obj0);
6092 if (arg1 == NULL) SWIG_fail;
6093 temp1 = true;
6094 }
6095 if (obj1) {
6096 {
6097 arg2 = wxString_in_helper(obj1);
6098 if (arg2 == NULL) SWIG_fail;
6099 temp2 = true;
6100 }
6101 }
6102 if (obj2) {
6103 {
6104 arg3 = wxString_in_helper(obj2);
6105 if (arg3 == NULL) SWIG_fail;
6106 temp3 = true;
6107 }
6108 }
6109 if (obj3) {
6110 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6111 if (!SWIG_IsOK(res4)) {
6112 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetPasswordFromUser" "', expected argument " "4"" of type '" "wxWindow *""'");
6113 }
6114 arg4 = reinterpret_cast< wxWindow * >(argp4);
6115 }
6116 {
6117 if (!wxPyCheckForApp()) SWIG_fail;
6118 PyThreadState* __tstate = wxPyBeginAllowThreads();
6119 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
6120 wxPyEndAllowThreads(__tstate);
6121 if (PyErr_Occurred()) SWIG_fail;
6122 }
6123 {
6124 #if wxUSE_UNICODE
6125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6126 #else
6127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6128 #endif
6129 }
6130 {
6131 if (temp1)
6132 delete arg1;
6133 }
6134 {
6135 if (temp2)
6136 delete arg2;
6137 }
6138 {
6139 if (temp3)
6140 delete arg3;
6141 }
6142 return resultobj;
6143 fail:
6144 {
6145 if (temp1)
6146 delete arg1;
6147 }
6148 {
6149 if (temp2)
6150 delete arg2;
6151 }
6152 {
6153 if (temp3)
6154 delete arg3;
6155 }
6156 return NULL;
6157 }
6158
6159
6160 SWIGINTERN PyObject *_wrap_GetSingleChoice(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj = 0;
6162 wxString *arg1 = 0 ;
6163 wxString *arg2 = 0 ;
6164 int arg3 ;
6165 wxString *arg4 = (wxString *) 0 ;
6166 wxWindow *arg5 = (wxWindow *) NULL ;
6167 int arg6 = (int) -1 ;
6168 int arg7 = (int) -1 ;
6169 bool arg8 = (bool) true ;
6170 int arg9 = (int) 150 ;
6171 int arg10 = (int) 200 ;
6172 wxString result;
6173 bool temp1 = false ;
6174 bool temp2 = false ;
6175 void *argp5 = 0 ;
6176 int res5 = 0 ;
6177 int val6 ;
6178 int ecode6 = 0 ;
6179 int val7 ;
6180 int ecode7 = 0 ;
6181 bool val8 ;
6182 int ecode8 = 0 ;
6183 int val9 ;
6184 int ecode9 = 0 ;
6185 int val10 ;
6186 int ecode10 = 0 ;
6187 PyObject * obj0 = 0 ;
6188 PyObject * obj1 = 0 ;
6189 PyObject * obj2 = 0 ;
6190 PyObject * obj3 = 0 ;
6191 PyObject * obj4 = 0 ;
6192 PyObject * obj5 = 0 ;
6193 PyObject * obj6 = 0 ;
6194 PyObject * obj7 = 0 ;
6195 PyObject * obj8 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6201 {
6202 arg1 = wxString_in_helper(obj0);
6203 if (arg1 == NULL) SWIG_fail;
6204 temp1 = true;
6205 }
6206 {
6207 arg2 = wxString_in_helper(obj1);
6208 if (arg2 == NULL) SWIG_fail;
6209 temp2 = true;
6210 }
6211 {
6212 arg3 = PyList_Size(obj2);
6213 arg4 = wxString_LIST_helper(obj2);
6214 if (arg4 == NULL) SWIG_fail;
6215 }
6216 if (obj3) {
6217 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6218 if (!SWIG_IsOK(res5)) {
6219 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoice" "', expected argument " "5"" of type '" "wxWindow *""'");
6220 }
6221 arg5 = reinterpret_cast< wxWindow * >(argp5);
6222 }
6223 if (obj4) {
6224 ecode6 = SWIG_AsVal_int(obj4, &val6);
6225 if (!SWIG_IsOK(ecode6)) {
6226 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoice" "', expected argument " "6"" of type '" "int""'");
6227 }
6228 arg6 = static_cast< int >(val6);
6229 }
6230 if (obj5) {
6231 ecode7 = SWIG_AsVal_int(obj5, &val7);
6232 if (!SWIG_IsOK(ecode7)) {
6233 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoice" "', expected argument " "7"" of type '" "int""'");
6234 }
6235 arg7 = static_cast< int >(val7);
6236 }
6237 if (obj6) {
6238 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6239 if (!SWIG_IsOK(ecode8)) {
6240 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoice" "', expected argument " "8"" of type '" "bool""'");
6241 }
6242 arg8 = static_cast< bool >(val8);
6243 }
6244 if (obj7) {
6245 ecode9 = SWIG_AsVal_int(obj7, &val9);
6246 if (!SWIG_IsOK(ecode9)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoice" "', expected argument " "9"" of type '" "int""'");
6248 }
6249 arg9 = static_cast< int >(val9);
6250 }
6251 if (obj8) {
6252 ecode10 = SWIG_AsVal_int(obj8, &val10);
6253 if (!SWIG_IsOK(ecode10)) {
6254 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoice" "', expected argument " "10"" of type '" "int""'");
6255 }
6256 arg10 = static_cast< int >(val10);
6257 }
6258 {
6259 if (!wxPyCheckForApp()) SWIG_fail;
6260 PyThreadState* __tstate = wxPyBeginAllowThreads();
6261 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6262 wxPyEndAllowThreads(__tstate);
6263 if (PyErr_Occurred()) SWIG_fail;
6264 }
6265 {
6266 #if wxUSE_UNICODE
6267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6268 #else
6269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6270 #endif
6271 }
6272 {
6273 if (temp1)
6274 delete arg1;
6275 }
6276 {
6277 if (temp2)
6278 delete arg2;
6279 }
6280 {
6281 if (arg4) delete [] arg4;
6282 }
6283 return resultobj;
6284 fail:
6285 {
6286 if (temp1)
6287 delete arg1;
6288 }
6289 {
6290 if (temp2)
6291 delete arg2;
6292 }
6293 {
6294 if (arg4) delete [] arg4;
6295 }
6296 return NULL;
6297 }
6298
6299
6300 SWIGINTERN PyObject *_wrap_GetSingleChoiceIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6301 PyObject *resultobj = 0;
6302 wxString *arg1 = 0 ;
6303 wxString *arg2 = 0 ;
6304 int arg3 ;
6305 wxString *arg4 = (wxString *) 0 ;
6306 wxWindow *arg5 = (wxWindow *) NULL ;
6307 int arg6 = (int) -1 ;
6308 int arg7 = (int) -1 ;
6309 bool arg8 = (bool) true ;
6310 int arg9 = (int) 150 ;
6311 int arg10 = (int) 200 ;
6312 int result;
6313 bool temp1 = false ;
6314 bool temp2 = false ;
6315 void *argp5 = 0 ;
6316 int res5 = 0 ;
6317 int val6 ;
6318 int ecode6 = 0 ;
6319 int val7 ;
6320 int ecode7 = 0 ;
6321 bool val8 ;
6322 int ecode8 = 0 ;
6323 int val9 ;
6324 int ecode9 = 0 ;
6325 int val10 ;
6326 int ecode10 = 0 ;
6327 PyObject * obj0 = 0 ;
6328 PyObject * obj1 = 0 ;
6329 PyObject * obj2 = 0 ;
6330 PyObject * obj3 = 0 ;
6331 PyObject * obj4 = 0 ;
6332 PyObject * obj5 = 0 ;
6333 PyObject * obj6 = 0 ;
6334 PyObject * obj7 = 0 ;
6335 PyObject * obj8 = 0 ;
6336 char * kwnames[] = {
6337 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
6338 };
6339
6340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
6341 {
6342 arg1 = wxString_in_helper(obj0);
6343 if (arg1 == NULL) SWIG_fail;
6344 temp1 = true;
6345 }
6346 {
6347 arg2 = wxString_in_helper(obj1);
6348 if (arg2 == NULL) SWIG_fail;
6349 temp2 = true;
6350 }
6351 {
6352 arg3 = PyList_Size(obj2);
6353 arg4 = wxString_LIST_helper(obj2);
6354 if (arg4 == NULL) SWIG_fail;
6355 }
6356 if (obj3) {
6357 res5 = SWIG_ConvertPtr(obj3, &argp5,SWIGTYPE_p_wxWindow, 0 | 0 );
6358 if (!SWIG_IsOK(res5)) {
6359 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GetSingleChoiceIndex" "', expected argument " "5"" of type '" "wxWindow *""'");
6360 }
6361 arg5 = reinterpret_cast< wxWindow * >(argp5);
6362 }
6363 if (obj4) {
6364 ecode6 = SWIG_AsVal_int(obj4, &val6);
6365 if (!SWIG_IsOK(ecode6)) {
6366 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GetSingleChoiceIndex" "', expected argument " "6"" of type '" "int""'");
6367 }
6368 arg6 = static_cast< int >(val6);
6369 }
6370 if (obj5) {
6371 ecode7 = SWIG_AsVal_int(obj5, &val7);
6372 if (!SWIG_IsOK(ecode7)) {
6373 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "GetSingleChoiceIndex" "', expected argument " "7"" of type '" "int""'");
6374 }
6375 arg7 = static_cast< int >(val7);
6376 }
6377 if (obj6) {
6378 ecode8 = SWIG_AsVal_bool(obj6, &val8);
6379 if (!SWIG_IsOK(ecode8)) {
6380 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GetSingleChoiceIndex" "', expected argument " "8"" of type '" "bool""'");
6381 }
6382 arg8 = static_cast< bool >(val8);
6383 }
6384 if (obj7) {
6385 ecode9 = SWIG_AsVal_int(obj7, &val9);
6386 if (!SWIG_IsOK(ecode9)) {
6387 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GetSingleChoiceIndex" "', expected argument " "9"" of type '" "int""'");
6388 }
6389 arg9 = static_cast< int >(val9);
6390 }
6391 if (obj8) {
6392 ecode10 = SWIG_AsVal_int(obj8, &val10);
6393 if (!SWIG_IsOK(ecode10)) {
6394 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "GetSingleChoiceIndex" "', expected argument " "10"" of type '" "int""'");
6395 }
6396 arg10 = static_cast< int >(val10);
6397 }
6398 {
6399 if (!wxPyCheckForApp()) SWIG_fail;
6400 PyThreadState* __tstate = wxPyBeginAllowThreads();
6401 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
6402 wxPyEndAllowThreads(__tstate);
6403 if (PyErr_Occurred()) SWIG_fail;
6404 }
6405 resultobj = SWIG_From_int(static_cast< int >(result));
6406 {
6407 if (temp1)
6408 delete arg1;
6409 }
6410 {
6411 if (temp2)
6412 delete arg2;
6413 }
6414 {
6415 if (arg4) delete [] arg4;
6416 }
6417 return resultobj;
6418 fail:
6419 {
6420 if (temp1)
6421 delete arg1;
6422 }
6423 {
6424 if (temp2)
6425 delete arg2;
6426 }
6427 {
6428 if (arg4) delete [] arg4;
6429 }
6430 return NULL;
6431 }
6432
6433
6434 SWIGINTERN PyObject *_wrap_MessageBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6435 PyObject *resultobj = 0;
6436 wxString *arg1 = 0 ;
6437 wxString const &arg2_defvalue = wxPyEmptyString ;
6438 wxString *arg2 = (wxString *) &arg2_defvalue ;
6439 int arg3 = (int) wxOK|wxCENTRE ;
6440 wxWindow *arg4 = (wxWindow *) NULL ;
6441 int arg5 = (int) -1 ;
6442 int arg6 = (int) -1 ;
6443 int result;
6444 bool temp1 = false ;
6445 bool temp2 = false ;
6446 int val3 ;
6447 int ecode3 = 0 ;
6448 void *argp4 = 0 ;
6449 int res4 = 0 ;
6450 int val5 ;
6451 int ecode5 = 0 ;
6452 int val6 ;
6453 int ecode6 = 0 ;
6454 PyObject * obj0 = 0 ;
6455 PyObject * obj1 = 0 ;
6456 PyObject * obj2 = 0 ;
6457 PyObject * obj3 = 0 ;
6458 PyObject * obj4 = 0 ;
6459 PyObject * obj5 = 0 ;
6460 char * kwnames[] = {
6461 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
6462 };
6463
6464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
6465 {
6466 arg1 = wxString_in_helper(obj0);
6467 if (arg1 == NULL) SWIG_fail;
6468 temp1 = true;
6469 }
6470 if (obj1) {
6471 {
6472 arg2 = wxString_in_helper(obj1);
6473 if (arg2 == NULL) SWIG_fail;
6474 temp2 = true;
6475 }
6476 }
6477 if (obj2) {
6478 ecode3 = SWIG_AsVal_int(obj2, &val3);
6479 if (!SWIG_IsOK(ecode3)) {
6480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MessageBox" "', expected argument " "3"" of type '" "int""'");
6481 }
6482 arg3 = static_cast< int >(val3);
6483 }
6484 if (obj3) {
6485 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
6486 if (!SWIG_IsOK(res4)) {
6487 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MessageBox" "', expected argument " "4"" of type '" "wxWindow *""'");
6488 }
6489 arg4 = reinterpret_cast< wxWindow * >(argp4);
6490 }
6491 if (obj4) {
6492 ecode5 = SWIG_AsVal_int(obj4, &val5);
6493 if (!SWIG_IsOK(ecode5)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MessageBox" "', expected argument " "5"" of type '" "int""'");
6495 }
6496 arg5 = static_cast< int >(val5);
6497 }
6498 if (obj5) {
6499 ecode6 = SWIG_AsVal_int(obj5, &val6);
6500 if (!SWIG_IsOK(ecode6)) {
6501 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MessageBox" "', expected argument " "6"" of type '" "int""'");
6502 }
6503 arg6 = static_cast< int >(val6);
6504 }
6505 {
6506 if (!wxPyCheckForApp()) SWIG_fail;
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_From_int(static_cast< int >(result));
6513 {
6514 if (temp1)
6515 delete arg1;
6516 }
6517 {
6518 if (temp2)
6519 delete arg2;
6520 }
6521 return resultobj;
6522 fail:
6523 {
6524 if (temp1)
6525 delete arg1;
6526 }
6527 {
6528 if (temp2)
6529 delete arg2;
6530 }
6531 return NULL;
6532 }
6533
6534
6535 SWIGINTERN PyObject *_wrap_ColourDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6536 PyObject *resultobj = 0;
6537 bool result;
6538
6539 if (!SWIG_Python_UnpackTuple(args,"ColourDisplay",0,0,0)) SWIG_fail;
6540 {
6541 if (!wxPyCheckForApp()) SWIG_fail;
6542 PyThreadState* __tstate = wxPyBeginAllowThreads();
6543 result = (bool)wxColourDisplay();
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 {
6548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6549 }
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_DisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6557 PyObject *resultobj = 0;
6558 int result;
6559
6560 if (!SWIG_Python_UnpackTuple(args,"DisplayDepth",0,0,0)) SWIG_fail;
6561 {
6562 if (!wxPyCheckForApp()) SWIG_fail;
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 result = (int)wxDisplayDepth();
6565 wxPyEndAllowThreads(__tstate);
6566 if (PyErr_Occurred()) SWIG_fail;
6567 }
6568 resultobj = SWIG_From_int(static_cast< int >(result));
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 SWIGINTERN PyObject *_wrap_GetDisplayDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6576 PyObject *resultobj = 0;
6577 int result;
6578
6579 if (!SWIG_Python_UnpackTuple(args,"GetDisplayDepth",0,0,0)) SWIG_fail;
6580 {
6581 if (!wxPyCheckForApp()) SWIG_fail;
6582 PyThreadState* __tstate = wxPyBeginAllowThreads();
6583 result = (int)wxGetDisplayDepth();
6584 wxPyEndAllowThreads(__tstate);
6585 if (PyErr_Occurred()) SWIG_fail;
6586 }
6587 resultobj = SWIG_From_int(static_cast< int >(result));
6588 return resultobj;
6589 fail:
6590 return NULL;
6591 }
6592
6593
6594 SWIGINTERN PyObject *_wrap_DisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6595 PyObject *resultobj = 0;
6596 int *arg1 = (int *) 0 ;
6597 int *arg2 = (int *) 0 ;
6598 int temp1 ;
6599 int res1 = SWIG_TMPOBJ ;
6600 int temp2 ;
6601 int res2 = SWIG_TMPOBJ ;
6602
6603 arg1 = &temp1;
6604 arg2 = &temp2;
6605 if (!SWIG_Python_UnpackTuple(args,"DisplaySize",0,0,0)) SWIG_fail;
6606 {
6607 if (!wxPyCheckForApp()) SWIG_fail;
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 wxDisplaySize(arg1,arg2);
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 resultobj = SWIG_Py_Void();
6614 if (SWIG_IsTmpObj(res1)) {
6615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6616 } else {
6617 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6619 }
6620 if (SWIG_IsTmpObj(res2)) {
6621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6622 } else {
6623 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6625 }
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 SWIGINTERN PyObject *_wrap_GetDisplaySize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6633 PyObject *resultobj = 0;
6634 wxSize result;
6635
6636 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySize",0,0,0)) SWIG_fail;
6637 {
6638 if (!wxPyCheckForApp()) SWIG_fail;
6639 PyThreadState* __tstate = wxPyBeginAllowThreads();
6640 result = wxGetDisplaySize();
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 SWIGINTERN PyObject *_wrap_DisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6652 PyObject *resultobj = 0;
6653 int *arg1 = (int *) 0 ;
6654 int *arg2 = (int *) 0 ;
6655 int temp1 ;
6656 int res1 = SWIG_TMPOBJ ;
6657 int temp2 ;
6658 int res2 = SWIG_TMPOBJ ;
6659
6660 arg1 = &temp1;
6661 arg2 = &temp2;
6662 if (!SWIG_Python_UnpackTuple(args,"DisplaySizeMM",0,0,0)) SWIG_fail;
6663 {
6664 if (!wxPyCheckForApp()) SWIG_fail;
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 wxDisplaySizeMM(arg1,arg2);
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 resultobj = SWIG_Py_Void();
6671 if (SWIG_IsTmpObj(res1)) {
6672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6673 } else {
6674 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6676 }
6677 if (SWIG_IsTmpObj(res2)) {
6678 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6679 } else {
6680 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6682 }
6683 return resultobj;
6684 fail:
6685 return NULL;
6686 }
6687
6688
6689 SWIGINTERN PyObject *_wrap_GetDisplaySizeMM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6690 PyObject *resultobj = 0;
6691 wxSize result;
6692
6693 if (!SWIG_Python_UnpackTuple(args,"GetDisplaySizeMM",0,0,0)) SWIG_fail;
6694 {
6695 if (!wxPyCheckForApp()) SWIG_fail;
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 result = wxGetDisplaySizeMM();
6698 wxPyEndAllowThreads(__tstate);
6699 if (PyErr_Occurred()) SWIG_fail;
6700 }
6701 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6702 return resultobj;
6703 fail:
6704 return NULL;
6705 }
6706
6707
6708 SWIGINTERN PyObject *_wrap_ClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6709 PyObject *resultobj = 0;
6710 int *arg1 = (int *) 0 ;
6711 int *arg2 = (int *) 0 ;
6712 int *arg3 = (int *) 0 ;
6713 int *arg4 = (int *) 0 ;
6714 int temp1 ;
6715 int res1 = SWIG_TMPOBJ ;
6716 int temp2 ;
6717 int res2 = SWIG_TMPOBJ ;
6718 int temp3 ;
6719 int res3 = SWIG_TMPOBJ ;
6720 int temp4 ;
6721 int res4 = SWIG_TMPOBJ ;
6722
6723 arg1 = &temp1;
6724 arg2 = &temp2;
6725 arg3 = &temp3;
6726 arg4 = &temp4;
6727 if (!SWIG_Python_UnpackTuple(args,"ClientDisplayRect",0,0,0)) SWIG_fail;
6728 {
6729 if (!wxPyCheckForApp()) SWIG_fail;
6730 PyThreadState* __tstate = wxPyBeginAllowThreads();
6731 wxClientDisplayRect(arg1,arg2,arg3,arg4);
6732 wxPyEndAllowThreads(__tstate);
6733 if (PyErr_Occurred()) SWIG_fail;
6734 }
6735 resultobj = SWIG_Py_Void();
6736 if (SWIG_IsTmpObj(res1)) {
6737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
6738 } else {
6739 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
6741 }
6742 if (SWIG_IsTmpObj(res2)) {
6743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
6744 } else {
6745 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
6747 }
6748 if (SWIG_IsTmpObj(res3)) {
6749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
6750 } else {
6751 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
6753 }
6754 if (SWIG_IsTmpObj(res4)) {
6755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
6756 } else {
6757 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
6758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
6759 }
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 SWIGINTERN PyObject *_wrap_GetClientDisplayRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6767 PyObject *resultobj = 0;
6768 wxRect result;
6769
6770 if (!SWIG_Python_UnpackTuple(args,"GetClientDisplayRect",0,0,0)) SWIG_fail;
6771 {
6772 if (!wxPyCheckForApp()) SWIG_fail;
6773 PyThreadState* __tstate = wxPyBeginAllowThreads();
6774 result = wxGetClientDisplayRect();
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 SWIGINTERN PyObject *_wrap_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj = 0;
6787 wxCursor *arg1 = 0 ;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 PyObject * obj0 = 0 ;
6791 char * kwnames[] = {
6792 (char *) "cursor", NULL
6793 };
6794
6795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) SWIG_fail;
6796 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxCursor, 0 );
6797 if (!SWIG_IsOK(res1)) {
6798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6799 }
6800 if (!argp1) {
6801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursor" "', expected argument " "1"" of type '" "wxCursor &""'");
6802 }
6803 arg1 = reinterpret_cast< wxCursor * >(argp1);
6804 {
6805 if (!wxPyCheckForApp()) SWIG_fail;
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 wxSetCursor(*arg1);
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 resultobj = SWIG_Py_Void();
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_GetXDisplay(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6819 PyObject *resultobj = 0;
6820 void *result = 0 ;
6821
6822 if (!SWIG_Python_UnpackTuple(args,"GetXDisplay",0,0,0)) SWIG_fail;
6823 {
6824 if (!wxPyCheckForApp()) SWIG_fail;
6825 PyThreadState* __tstate = wxPyBeginAllowThreads();
6826 result = (void *)wxGetXDisplay();
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
6831 return resultobj;
6832 fail:
6833 return NULL;
6834 }
6835
6836
6837 SWIGINTERN PyObject *_wrap_BeginBusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6838 PyObject *resultobj = 0;
6839 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6840 void *argp1 = 0 ;
6841 int res1 = 0 ;
6842 PyObject * obj0 = 0 ;
6843 char * kwnames[] = {
6844 (char *) "cursor", NULL
6845 };
6846
6847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) SWIG_fail;
6848 if (obj0) {
6849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
6850 if (!SWIG_IsOK(res1)) {
6851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BeginBusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
6852 }
6853 arg1 = reinterpret_cast< wxCursor * >(argp1);
6854 }
6855 {
6856 if (!wxPyCheckForApp()) SWIG_fail;
6857 PyThreadState* __tstate = wxPyBeginAllowThreads();
6858 wxBeginBusyCursor(arg1);
6859 wxPyEndAllowThreads(__tstate);
6860 if (PyErr_Occurred()) SWIG_fail;
6861 }
6862 resultobj = SWIG_Py_Void();
6863 return resultobj;
6864 fail:
6865 return NULL;
6866 }
6867
6868
6869 SWIGINTERN PyObject *_wrap_GetMousePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6870 PyObject *resultobj = 0;
6871 wxPoint result;
6872
6873 if (!SWIG_Python_UnpackTuple(args,"GetMousePosition",0,0,0)) SWIG_fail;
6874 {
6875 if (!wxPyCheckForApp()) SWIG_fail;
6876 PyThreadState* __tstate = wxPyBeginAllowThreads();
6877 result = wxGetMousePosition();
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 SWIGINTERN PyObject *_wrap_FindWindowAtPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6889 PyObject *resultobj = 0;
6890 wxWindow *result = 0 ;
6891
6892 if (!SWIG_Python_UnpackTuple(args,"FindWindowAtPointer",0,0,0)) SWIG_fail;
6893 {
6894 if (!wxPyCheckForApp()) SWIG_fail;
6895 PyThreadState* __tstate = wxPyBeginAllowThreads();
6896 result = (wxWindow *)FindWindowAtPointer();
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 {
6901 resultobj = wxPyMake_wxObject(result, 0);
6902 }
6903 return resultobj;
6904 fail:
6905 return NULL;
6906 }
6907
6908
6909 SWIGINTERN PyObject *_wrap_GetActiveWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6910 PyObject *resultobj = 0;
6911 wxWindow *result = 0 ;
6912
6913 if (!SWIG_Python_UnpackTuple(args,"GetActiveWindow",0,0,0)) SWIG_fail;
6914 {
6915 if (!wxPyCheckForApp()) SWIG_fail;
6916 PyThreadState* __tstate = wxPyBeginAllowThreads();
6917 result = (wxWindow *)wxGetActiveWindow();
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 {
6922 resultobj = wxPyMake_wxObject(result, 0);
6923 }
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_GenericFindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj = 0;
6932 wxPoint *arg1 = 0 ;
6933 wxWindow *result = 0 ;
6934 wxPoint temp1 ;
6935 PyObject * obj0 = 0 ;
6936 char * kwnames[] = {
6937 (char *) "pt", NULL
6938 };
6939
6940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6941 {
6942 arg1 = &temp1;
6943 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6944 }
6945 {
6946 if (!wxPyCheckForApp()) SWIG_fail;
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 {
6953 resultobj = wxPyMake_wxObject(result, 0);
6954 }
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 SWIGINTERN PyObject *_wrap_FindWindowAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj = 0;
6963 wxPoint *arg1 = 0 ;
6964 wxWindow *result = 0 ;
6965 wxPoint temp1 ;
6966 PyObject * obj0 = 0 ;
6967 char * kwnames[] = {
6968 (char *) "pt", NULL
6969 };
6970
6971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) SWIG_fail;
6972 {
6973 arg1 = &temp1;
6974 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6975 }
6976 {
6977 if (!wxPyCheckForApp()) SWIG_fail;
6978 PyThreadState* __tstate = wxPyBeginAllowThreads();
6979 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
6980 wxPyEndAllowThreads(__tstate);
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 {
6984 resultobj = wxPyMake_wxObject(result, 0);
6985 }
6986 return resultobj;
6987 fail:
6988 return NULL;
6989 }
6990
6991
6992 SWIGINTERN PyObject *_wrap_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6993 PyObject *resultobj = 0;
6994 wxWindow *arg1 = (wxWindow *) 0 ;
6995 wxWindow *result = 0 ;
6996 void *argp1 = 0 ;
6997 int res1 = 0 ;
6998 PyObject * obj0 = 0 ;
6999 char * kwnames[] = {
7000 (char *) "win", NULL
7001 };
7002
7003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) SWIG_fail;
7004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
7005 if (!SWIG_IsOK(res1)) {
7006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
7007 }
7008 arg1 = reinterpret_cast< wxWindow * >(argp1);
7009 {
7010 if (!wxPyCheckForApp()) SWIG_fail;
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 result = (wxWindow *)wxGetTopLevelParent(arg1);
7013 wxPyEndAllowThreads(__tstate);
7014 if (PyErr_Occurred()) SWIG_fail;
7015 }
7016 {
7017 resultobj = wxPyMake_wxObject(result, 0);
7018 }
7019 return resultobj;
7020 fail:
7021 return NULL;
7022 }
7023
7024
7025 SWIGINTERN PyObject *_wrap_LaunchDefaultBrowser(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7026 PyObject *resultobj = 0;
7027 wxString *arg1 = 0 ;
7028 bool result;
7029 bool temp1 = false ;
7030 PyObject * obj0 = 0 ;
7031 char * kwnames[] = {
7032 (char *) "url", NULL
7033 };
7034
7035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LaunchDefaultBrowser",kwnames,&obj0)) SWIG_fail;
7036 {
7037 arg1 = wxString_in_helper(obj0);
7038 if (arg1 == NULL) SWIG_fail;
7039 temp1 = true;
7040 }
7041 {
7042 PyThreadState* __tstate = wxPyBeginAllowThreads();
7043 result = (bool)wxLaunchDefaultBrowser((wxString const &)*arg1);
7044 wxPyEndAllowThreads(__tstate);
7045 if (PyErr_Occurred()) SWIG_fail;
7046 }
7047 {
7048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7049 }
7050 {
7051 if (temp1)
7052 delete arg1;
7053 }
7054 return resultobj;
7055 fail:
7056 {
7057 if (temp1)
7058 delete arg1;
7059 }
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_GetKeyState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxKeyCode arg1 ;
7067 bool result;
7068 int val1 ;
7069 int ecode1 = 0 ;
7070 PyObject * obj0 = 0 ;
7071 char * kwnames[] = {
7072 (char *) "key", NULL
7073 };
7074
7075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) SWIG_fail;
7076 ecode1 = SWIG_AsVal_int(obj0, &val1);
7077 if (!SWIG_IsOK(ecode1)) {
7078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetKeyState" "', expected argument " "1"" of type '" "wxKeyCode""'");
7079 }
7080 arg1 = static_cast< wxKeyCode >(val1);
7081 {
7082 if (!wxPyCheckForApp()) SWIG_fail;
7083 PyThreadState* __tstate = wxPyBeginAllowThreads();
7084 result = (bool)wxGetKeyState(arg1);
7085 wxPyEndAllowThreads(__tstate);
7086 if (PyErr_Occurred()) SWIG_fail;
7087 }
7088 {
7089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7090 }
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 SWIGINTERN PyObject *_wrap_new_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098 PyObject *resultobj = 0;
7099 wxMouseState *result = 0 ;
7100
7101 if (!SWIG_Python_UnpackTuple(args,"new_MouseState",0,0,0)) SWIG_fail;
7102 {
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = (wxMouseState *)new wxMouseState();
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseState, SWIG_POINTER_NEW | 0 );
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 SWIGINTERN PyObject *_wrap_delete_MouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7116 PyObject *resultobj = 0;
7117 wxMouseState *arg1 = (wxMouseState *) 0 ;
7118 void *argp1 = 0 ;
7119 int res1 = 0 ;
7120 PyObject *swig_obj[1] ;
7121
7122 if (!args) SWIG_fail;
7123 swig_obj[0] = args;
7124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, SWIG_POINTER_DISOWN | 0 );
7125 if (!SWIG_IsOK(res1)) {
7126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MouseState" "', expected argument " "1"" of type '" "wxMouseState *""'");
7127 }
7128 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7129 {
7130 PyThreadState* __tstate = wxPyBeginAllowThreads();
7131 delete arg1;
7132
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_Py_Void();
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_MouseState_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7144 PyObject *resultobj = 0;
7145 wxMouseState *arg1 = (wxMouseState *) 0 ;
7146 int result;
7147 void *argp1 = 0 ;
7148 int res1 = 0 ;
7149 PyObject *swig_obj[1] ;
7150
7151 if (!args) SWIG_fail;
7152 swig_obj[0] = args;
7153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7154 if (!SWIG_IsOK(res1)) {
7155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7156 }
7157 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 result = (int)(arg1)->GetX();
7161 wxPyEndAllowThreads(__tstate);
7162 if (PyErr_Occurred()) SWIG_fail;
7163 }
7164 resultobj = SWIG_From_int(static_cast< int >(result));
7165 return resultobj;
7166 fail:
7167 return NULL;
7168 }
7169
7170
7171 SWIGINTERN PyObject *_wrap_MouseState_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7172 PyObject *resultobj = 0;
7173 wxMouseState *arg1 = (wxMouseState *) 0 ;
7174 int result;
7175 void *argp1 = 0 ;
7176 int res1 = 0 ;
7177 PyObject *swig_obj[1] ;
7178
7179 if (!args) SWIG_fail;
7180 swig_obj[0] = args;
7181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7182 if (!SWIG_IsOK(res1)) {
7183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_GetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7184 }
7185 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7186 {
7187 PyThreadState* __tstate = wxPyBeginAllowThreads();
7188 result = (int)(arg1)->GetY();
7189 wxPyEndAllowThreads(__tstate);
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_From_int(static_cast< int >(result));
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 SWIGINTERN PyObject *_wrap_MouseState_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7200 PyObject *resultobj = 0;
7201 wxMouseState *arg1 = (wxMouseState *) 0 ;
7202 bool result;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 PyObject *swig_obj[1] ;
7206
7207 if (!args) SWIG_fail;
7208 swig_obj[0] = args;
7209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7210 if (!SWIG_IsOK(res1)) {
7211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_LeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7212 }
7213 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7214 {
7215 PyThreadState* __tstate = wxPyBeginAllowThreads();
7216 result = (bool)(arg1)->LeftDown();
7217 wxPyEndAllowThreads(__tstate);
7218 if (PyErr_Occurred()) SWIG_fail;
7219 }
7220 {
7221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7222 }
7223 return resultobj;
7224 fail:
7225 return NULL;
7226 }
7227
7228
7229 SWIGINTERN PyObject *_wrap_MouseState_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7230 PyObject *resultobj = 0;
7231 wxMouseState *arg1 = (wxMouseState *) 0 ;
7232 bool result;
7233 void *argp1 = 0 ;
7234 int res1 = 0 ;
7235 PyObject *swig_obj[1] ;
7236
7237 if (!args) SWIG_fail;
7238 swig_obj[0] = args;
7239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7242 }
7243 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 result = (bool)(arg1)->MiddleDown();
7247 wxPyEndAllowThreads(__tstate);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 {
7251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7252 }
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 SWIGINTERN PyObject *_wrap_MouseState_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7260 PyObject *resultobj = 0;
7261 wxMouseState *arg1 = (wxMouseState *) 0 ;
7262 bool result;
7263 void *argp1 = 0 ;
7264 int res1 = 0 ;
7265 PyObject *swig_obj[1] ;
7266
7267 if (!args) SWIG_fail;
7268 swig_obj[0] = args;
7269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7270 if (!SWIG_IsOK(res1)) {
7271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_RightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7272 }
7273 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7274 {
7275 PyThreadState* __tstate = wxPyBeginAllowThreads();
7276 result = (bool)(arg1)->RightDown();
7277 wxPyEndAllowThreads(__tstate);
7278 if (PyErr_Occurred()) SWIG_fail;
7279 }
7280 {
7281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7282 }
7283 return resultobj;
7284 fail:
7285 return NULL;
7286 }
7287
7288
7289 SWIGINTERN PyObject *_wrap_MouseState_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7290 PyObject *resultobj = 0;
7291 wxMouseState *arg1 = (wxMouseState *) 0 ;
7292 bool result;
7293 void *argp1 = 0 ;
7294 int res1 = 0 ;
7295 PyObject *swig_obj[1] ;
7296
7297 if (!args) SWIG_fail;
7298 swig_obj[0] = args;
7299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7300 if (!SWIG_IsOK(res1)) {
7301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7302 }
7303 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (bool)(arg1)->ControlDown();
7307 wxPyEndAllowThreads(__tstate);
7308 if (PyErr_Occurred()) SWIG_fail;
7309 }
7310 {
7311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7312 }
7313 return resultobj;
7314 fail:
7315 return NULL;
7316 }
7317
7318
7319 SWIGINTERN PyObject *_wrap_MouseState_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7320 PyObject *resultobj = 0;
7321 wxMouseState *arg1 = (wxMouseState *) 0 ;
7322 bool result;
7323 void *argp1 = 0 ;
7324 int res1 = 0 ;
7325 PyObject *swig_obj[1] ;
7326
7327 if (!args) SWIG_fail;
7328 swig_obj[0] = args;
7329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7330 if (!SWIG_IsOK(res1)) {
7331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_ShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7332 }
7333 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7334 {
7335 PyThreadState* __tstate = wxPyBeginAllowThreads();
7336 result = (bool)(arg1)->ShiftDown();
7337 wxPyEndAllowThreads(__tstate);
7338 if (PyErr_Occurred()) SWIG_fail;
7339 }
7340 {
7341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7342 }
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 SWIGINTERN PyObject *_wrap_MouseState_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7350 PyObject *resultobj = 0;
7351 wxMouseState *arg1 = (wxMouseState *) 0 ;
7352 bool result;
7353 void *argp1 = 0 ;
7354 int res1 = 0 ;
7355 PyObject *swig_obj[1] ;
7356
7357 if (!args) SWIG_fail;
7358 swig_obj[0] = args;
7359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7360 if (!SWIG_IsOK(res1)) {
7361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_AltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7362 }
7363 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 result = (bool)(arg1)->AltDown();
7367 wxPyEndAllowThreads(__tstate);
7368 if (PyErr_Occurred()) SWIG_fail;
7369 }
7370 {
7371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7372 }
7373 return resultobj;
7374 fail:
7375 return NULL;
7376 }
7377
7378
7379 SWIGINTERN PyObject *_wrap_MouseState_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7380 PyObject *resultobj = 0;
7381 wxMouseState *arg1 = (wxMouseState *) 0 ;
7382 bool result;
7383 void *argp1 = 0 ;
7384 int res1 = 0 ;
7385 PyObject *swig_obj[1] ;
7386
7387 if (!args) SWIG_fail;
7388 swig_obj[0] = args;
7389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_MetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7392 }
7393 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 result = (bool)(arg1)->MetaDown();
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 {
7401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7402 }
7403 return resultobj;
7404 fail:
7405 return NULL;
7406 }
7407
7408
7409 SWIGINTERN PyObject *_wrap_MouseState_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7410 PyObject *resultobj = 0;
7411 wxMouseState *arg1 = (wxMouseState *) 0 ;
7412 bool result;
7413 void *argp1 = 0 ;
7414 int res1 = 0 ;
7415 PyObject *swig_obj[1] ;
7416
7417 if (!args) SWIG_fail;
7418 swig_obj[0] = args;
7419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7420 if (!SWIG_IsOK(res1)) {
7421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_CmdDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7422 }
7423 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7424 {
7425 PyThreadState* __tstate = wxPyBeginAllowThreads();
7426 result = (bool)(arg1)->CmdDown();
7427 wxPyEndAllowThreads(__tstate);
7428 if (PyErr_Occurred()) SWIG_fail;
7429 }
7430 {
7431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7432 }
7433 return resultobj;
7434 fail:
7435 return NULL;
7436 }
7437
7438
7439 SWIGINTERN PyObject *_wrap_MouseState_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7440 PyObject *resultobj = 0;
7441 wxMouseState *arg1 = (wxMouseState *) 0 ;
7442 int arg2 ;
7443 void *argp1 = 0 ;
7444 int res1 = 0 ;
7445 int val2 ;
7446 int ecode2 = 0 ;
7447 PyObject * obj0 = 0 ;
7448 PyObject * obj1 = 0 ;
7449 char * kwnames[] = {
7450 (char *) "self",(char *) "x", NULL
7451 };
7452
7453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
7454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7455 if (!SWIG_IsOK(res1)) {
7456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetX" "', expected argument " "1"" of type '" "wxMouseState *""'");
7457 }
7458 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7459 ecode2 = SWIG_AsVal_int(obj1, &val2);
7460 if (!SWIG_IsOK(ecode2)) {
7461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetX" "', expected argument " "2"" of type '" "int""'");
7462 }
7463 arg2 = static_cast< int >(val2);
7464 {
7465 PyThreadState* __tstate = wxPyBeginAllowThreads();
7466 (arg1)->SetX(arg2);
7467 wxPyEndAllowThreads(__tstate);
7468 if (PyErr_Occurred()) SWIG_fail;
7469 }
7470 resultobj = SWIG_Py_Void();
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 SWIGINTERN PyObject *_wrap_MouseState_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7478 PyObject *resultobj = 0;
7479 wxMouseState *arg1 = (wxMouseState *) 0 ;
7480 int arg2 ;
7481 void *argp1 = 0 ;
7482 int res1 = 0 ;
7483 int val2 ;
7484 int ecode2 = 0 ;
7485 PyObject * obj0 = 0 ;
7486 PyObject * obj1 = 0 ;
7487 char * kwnames[] = {
7488 (char *) "self",(char *) "y", NULL
7489 };
7490
7491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
7492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7493 if (!SWIG_IsOK(res1)) {
7494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetY" "', expected argument " "1"" of type '" "wxMouseState *""'");
7495 }
7496 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7497 ecode2 = SWIG_AsVal_int(obj1, &val2);
7498 if (!SWIG_IsOK(ecode2)) {
7499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetY" "', expected argument " "2"" of type '" "int""'");
7500 }
7501 arg2 = static_cast< int >(val2);
7502 {
7503 PyThreadState* __tstate = wxPyBeginAllowThreads();
7504 (arg1)->SetY(arg2);
7505 wxPyEndAllowThreads(__tstate);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 resultobj = SWIG_Py_Void();
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 SWIGINTERN PyObject *_wrap_MouseState_SetLeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj = 0;
7517 wxMouseState *arg1 = (wxMouseState *) 0 ;
7518 bool arg2 ;
7519 void *argp1 = 0 ;
7520 int res1 = 0 ;
7521 bool val2 ;
7522 int ecode2 = 0 ;
7523 PyObject * obj0 = 0 ;
7524 PyObject * obj1 = 0 ;
7525 char * kwnames[] = {
7526 (char *) "self",(char *) "down", NULL
7527 };
7528
7529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetLeftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7531 if (!SWIG_IsOK(res1)) {
7532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetLeftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7533 }
7534 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7535 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7536 if (!SWIG_IsOK(ecode2)) {
7537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetLeftDown" "', expected argument " "2"" of type '" "bool""'");
7538 }
7539 arg2 = static_cast< bool >(val2);
7540 {
7541 PyThreadState* __tstate = wxPyBeginAllowThreads();
7542 (arg1)->SetLeftDown(arg2);
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 resultobj = SWIG_Py_Void();
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 SWIGINTERN PyObject *_wrap_MouseState_SetMiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7554 PyObject *resultobj = 0;
7555 wxMouseState *arg1 = (wxMouseState *) 0 ;
7556 bool arg2 ;
7557 void *argp1 = 0 ;
7558 int res1 = 0 ;
7559 bool val2 ;
7560 int ecode2 = 0 ;
7561 PyObject * obj0 = 0 ;
7562 PyObject * obj1 = 0 ;
7563 char * kwnames[] = {
7564 (char *) "self",(char *) "down", NULL
7565 };
7566
7567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMiddleDown",kwnames,&obj0,&obj1)) SWIG_fail;
7568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7569 if (!SWIG_IsOK(res1)) {
7570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMiddleDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7571 }
7572 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7574 if (!SWIG_IsOK(ecode2)) {
7575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMiddleDown" "', expected argument " "2"" of type '" "bool""'");
7576 }
7577 arg2 = static_cast< bool >(val2);
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 (arg1)->SetMiddleDown(arg2);
7581 wxPyEndAllowThreads(__tstate);
7582 if (PyErr_Occurred()) SWIG_fail;
7583 }
7584 resultobj = SWIG_Py_Void();
7585 return resultobj;
7586 fail:
7587 return NULL;
7588 }
7589
7590
7591 SWIGINTERN PyObject *_wrap_MouseState_SetRightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7592 PyObject *resultobj = 0;
7593 wxMouseState *arg1 = (wxMouseState *) 0 ;
7594 bool arg2 ;
7595 void *argp1 = 0 ;
7596 int res1 = 0 ;
7597 bool val2 ;
7598 int ecode2 = 0 ;
7599 PyObject * obj0 = 0 ;
7600 PyObject * obj1 = 0 ;
7601 char * kwnames[] = {
7602 (char *) "self",(char *) "down", NULL
7603 };
7604
7605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetRightDown",kwnames,&obj0,&obj1)) SWIG_fail;
7606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7607 if (!SWIG_IsOK(res1)) {
7608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetRightDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7609 }
7610 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7611 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7612 if (!SWIG_IsOK(ecode2)) {
7613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetRightDown" "', expected argument " "2"" of type '" "bool""'");
7614 }
7615 arg2 = static_cast< bool >(val2);
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 (arg1)->SetRightDown(arg2);
7619 wxPyEndAllowThreads(__tstate);
7620 if (PyErr_Occurred()) SWIG_fail;
7621 }
7622 resultobj = SWIG_Py_Void();
7623 return resultobj;
7624 fail:
7625 return NULL;
7626 }
7627
7628
7629 SWIGINTERN PyObject *_wrap_MouseState_SetControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7630 PyObject *resultobj = 0;
7631 wxMouseState *arg1 = (wxMouseState *) 0 ;
7632 bool arg2 ;
7633 void *argp1 = 0 ;
7634 int res1 = 0 ;
7635 bool val2 ;
7636 int ecode2 = 0 ;
7637 PyObject * obj0 = 0 ;
7638 PyObject * obj1 = 0 ;
7639 char * kwnames[] = {
7640 (char *) "self",(char *) "down", NULL
7641 };
7642
7643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetControlDown",kwnames,&obj0,&obj1)) SWIG_fail;
7644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7645 if (!SWIG_IsOK(res1)) {
7646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetControlDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7647 }
7648 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7650 if (!SWIG_IsOK(ecode2)) {
7651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetControlDown" "', expected argument " "2"" of type '" "bool""'");
7652 }
7653 arg2 = static_cast< bool >(val2);
7654 {
7655 PyThreadState* __tstate = wxPyBeginAllowThreads();
7656 (arg1)->SetControlDown(arg2);
7657 wxPyEndAllowThreads(__tstate);
7658 if (PyErr_Occurred()) SWIG_fail;
7659 }
7660 resultobj = SWIG_Py_Void();
7661 return resultobj;
7662 fail:
7663 return NULL;
7664 }
7665
7666
7667 SWIGINTERN PyObject *_wrap_MouseState_SetShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7668 PyObject *resultobj = 0;
7669 wxMouseState *arg1 = (wxMouseState *) 0 ;
7670 bool arg2 ;
7671 void *argp1 = 0 ;
7672 int res1 = 0 ;
7673 bool val2 ;
7674 int ecode2 = 0 ;
7675 PyObject * obj0 = 0 ;
7676 PyObject * obj1 = 0 ;
7677 char * kwnames[] = {
7678 (char *) "self",(char *) "down", NULL
7679 };
7680
7681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetShiftDown",kwnames,&obj0,&obj1)) SWIG_fail;
7682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7683 if (!SWIG_IsOK(res1)) {
7684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetShiftDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7685 }
7686 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7688 if (!SWIG_IsOK(ecode2)) {
7689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetShiftDown" "', expected argument " "2"" of type '" "bool""'");
7690 }
7691 arg2 = static_cast< bool >(val2);
7692 {
7693 PyThreadState* __tstate = wxPyBeginAllowThreads();
7694 (arg1)->SetShiftDown(arg2);
7695 wxPyEndAllowThreads(__tstate);
7696 if (PyErr_Occurred()) SWIG_fail;
7697 }
7698 resultobj = SWIG_Py_Void();
7699 return resultobj;
7700 fail:
7701 return NULL;
7702 }
7703
7704
7705 SWIGINTERN PyObject *_wrap_MouseState_SetAltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7706 PyObject *resultobj = 0;
7707 wxMouseState *arg1 = (wxMouseState *) 0 ;
7708 bool arg2 ;
7709 void *argp1 = 0 ;
7710 int res1 = 0 ;
7711 bool val2 ;
7712 int ecode2 = 0 ;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 char * kwnames[] = {
7716 (char *) "self",(char *) "down", NULL
7717 };
7718
7719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetAltDown",kwnames,&obj0,&obj1)) SWIG_fail;
7720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7721 if (!SWIG_IsOK(res1)) {
7722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetAltDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7723 }
7724 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7725 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7726 if (!SWIG_IsOK(ecode2)) {
7727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetAltDown" "', expected argument " "2"" of type '" "bool""'");
7728 }
7729 arg2 = static_cast< bool >(val2);
7730 {
7731 PyThreadState* __tstate = wxPyBeginAllowThreads();
7732 (arg1)->SetAltDown(arg2);
7733 wxPyEndAllowThreads(__tstate);
7734 if (PyErr_Occurred()) SWIG_fail;
7735 }
7736 resultobj = SWIG_Py_Void();
7737 return resultobj;
7738 fail:
7739 return NULL;
7740 }
7741
7742
7743 SWIGINTERN PyObject *_wrap_MouseState_SetMetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7744 PyObject *resultobj = 0;
7745 wxMouseState *arg1 = (wxMouseState *) 0 ;
7746 bool arg2 ;
7747 void *argp1 = 0 ;
7748 int res1 = 0 ;
7749 bool val2 ;
7750 int ecode2 = 0 ;
7751 PyObject * obj0 = 0 ;
7752 PyObject * obj1 = 0 ;
7753 char * kwnames[] = {
7754 (char *) "self",(char *) "down", NULL
7755 };
7756
7757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseState_SetMetaDown",kwnames,&obj0,&obj1)) SWIG_fail;
7758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseState, 0 | 0 );
7759 if (!SWIG_IsOK(res1)) {
7760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseState_SetMetaDown" "', expected argument " "1"" of type '" "wxMouseState *""'");
7761 }
7762 arg1 = reinterpret_cast< wxMouseState * >(argp1);
7763 ecode2 = SWIG_AsVal_bool(obj1, &val2);
7764 if (!SWIG_IsOK(ecode2)) {
7765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseState_SetMetaDown" "', expected argument " "2"" of type '" "bool""'");
7766 }
7767 arg2 = static_cast< bool >(val2);
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 (arg1)->SetMetaDown(arg2);
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 resultobj = SWIG_Py_Void();
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 SWIGINTERN PyObject *MouseState_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7782 PyObject *obj;
7783 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7784 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseState, SWIG_NewClientData(obj));
7785 return SWIG_Py_Void();
7786 }
7787
7788 SWIGINTERN PyObject *MouseState_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7789 return SWIG_Python_InitShadowInstance(args);
7790 }
7791
7792 SWIGINTERN PyObject *_wrap_GetMouseState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7793 PyObject *resultobj = 0;
7794 wxMouseState result;
7795
7796 if (!SWIG_Python_UnpackTuple(args,"GetMouseState",0,0,0)) SWIG_fail;
7797 {
7798 PyThreadState* __tstate = wxPyBeginAllowThreads();
7799 result = wxGetMouseState();
7800 wxPyEndAllowThreads(__tstate);
7801 if (PyErr_Occurred()) SWIG_fail;
7802 }
7803 resultobj = SWIG_NewPointerObj((new wxMouseState(static_cast< const wxMouseState& >(result))), SWIGTYPE_p_wxMouseState, SWIG_POINTER_OWN | 0 );
7804 return resultobj;
7805 fail:
7806 return NULL;
7807 }
7808
7809
7810 SWIGINTERN PyObject *_wrap_WakeUpMainThread(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7811 PyObject *resultobj = 0;
7812
7813 if (!SWIG_Python_UnpackTuple(args,"WakeUpMainThread",0,0,0)) SWIG_fail;
7814 {
7815 if (!wxPyCheckForApp()) SWIG_fail;
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 wxWakeUpMainThread();
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 resultobj = SWIG_Py_Void();
7822 return resultobj;
7823 fail:
7824 return NULL;
7825 }
7826
7827
7828 SWIGINTERN PyObject *_wrap_MutexGuiEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7829 PyObject *resultobj = 0;
7830
7831 if (!SWIG_Python_UnpackTuple(args,"MutexGuiEnter",0,0,0)) SWIG_fail;
7832 {
7833 if (!wxPyCheckForApp()) SWIG_fail;
7834 PyThreadState* __tstate = wxPyBeginAllowThreads();
7835 wxMutexGuiEnter();
7836 wxPyEndAllowThreads(__tstate);
7837 if (PyErr_Occurred()) SWIG_fail;
7838 }
7839 resultobj = SWIG_Py_Void();
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 SWIGINTERN PyObject *_wrap_MutexGuiLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7847 PyObject *resultobj = 0;
7848
7849 if (!SWIG_Python_UnpackTuple(args,"MutexGuiLeave",0,0,0)) SWIG_fail;
7850 {
7851 if (!wxPyCheckForApp()) SWIG_fail;
7852 PyThreadState* __tstate = wxPyBeginAllowThreads();
7853 wxMutexGuiLeave();
7854 wxPyEndAllowThreads(__tstate);
7855 if (PyErr_Occurred()) SWIG_fail;
7856 }
7857 resultobj = SWIG_Py_Void();
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 SWIGINTERN PyObject *_wrap_new_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7865 PyObject *resultobj = 0;
7866 wxMutexGuiLocker *result = 0 ;
7867
7868 if (!SWIG_Python_UnpackTuple(args,"new_MutexGuiLocker",0,0,0)) SWIG_fail;
7869 {
7870 if (!wxPyCheckForApp()) SWIG_fail;
7871 PyThreadState* __tstate = wxPyBeginAllowThreads();
7872 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_NEW | 0 );
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 SWIGINTERN PyObject *_wrap_delete_MutexGuiLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7884 PyObject *resultobj = 0;
7885 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
7886 void *argp1 = 0 ;
7887 int res1 = 0 ;
7888 PyObject *swig_obj[1] ;
7889
7890 if (!args) SWIG_fail;
7891 swig_obj[0] = args;
7892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_DISOWN | 0 );
7893 if (!SWIG_IsOK(res1)) {
7894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MutexGuiLocker" "', expected argument " "1"" of type '" "wxMutexGuiLocker *""'");
7895 }
7896 arg1 = reinterpret_cast< wxMutexGuiLocker * >(argp1);
7897 {
7898 PyThreadState* __tstate = wxPyBeginAllowThreads();
7899 delete arg1;
7900
7901 wxPyEndAllowThreads(__tstate);
7902 if (PyErr_Occurred()) SWIG_fail;
7903 }
7904 resultobj = SWIG_Py_Void();
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 SWIGINTERN PyObject *MutexGuiLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7912 PyObject *obj;
7913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7914 SWIG_TypeNewClientData(SWIGTYPE_p_wxMutexGuiLocker, SWIG_NewClientData(obj));
7915 return SWIG_Py_Void();
7916 }
7917
7918 SWIGINTERN PyObject *MutexGuiLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7919 return SWIG_Python_InitShadowInstance(args);
7920 }
7921
7922 SWIGINTERN PyObject *_wrap_Thread_IsMain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7923 PyObject *resultobj = 0;
7924 bool result;
7925
7926 if (!SWIG_Python_UnpackTuple(args,"Thread_IsMain",0,0,0)) SWIG_fail;
7927 {
7928 PyThreadState* __tstate = wxPyBeginAllowThreads();
7929 result = (bool)wxThread_IsMain();
7930 wxPyEndAllowThreads(__tstate);
7931 if (PyErr_Occurred()) SWIG_fail;
7932 }
7933 {
7934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7935 }
7936 return resultobj;
7937 fail:
7938 return NULL;
7939 }
7940
7941
7942 SWIGINTERN PyObject *_wrap_new_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7943 PyObject *resultobj = 0;
7944 wxString *arg1 = 0 ;
7945 wxToolTip *result = 0 ;
7946 bool temp1 = false ;
7947 PyObject * obj0 = 0 ;
7948 char * kwnames[] = {
7949 (char *) "tip", NULL
7950 };
7951
7952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) SWIG_fail;
7953 {
7954 arg1 = wxString_in_helper(obj0);
7955 if (arg1 == NULL) SWIG_fail;
7956 temp1 = true;
7957 }
7958 {
7959 if (!wxPyCheckForApp()) SWIG_fail;
7960 PyThreadState* __tstate = wxPyBeginAllowThreads();
7961 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
7962 wxPyEndAllowThreads(__tstate);
7963 if (PyErr_Occurred()) SWIG_fail;
7964 }
7965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxToolTip, SWIG_POINTER_NEW | 0 );
7966 {
7967 if (temp1)
7968 delete arg1;
7969 }
7970 return resultobj;
7971 fail:
7972 {
7973 if (temp1)
7974 delete arg1;
7975 }
7976 return NULL;
7977 }
7978
7979
7980 SWIGINTERN PyObject *_wrap_delete_ToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7981 PyObject *resultobj = 0;
7982 wxToolTip *arg1 = (wxToolTip *) 0 ;
7983 void *argp1 = 0 ;
7984 int res1 = 0 ;
7985 PyObject *swig_obj[1] ;
7986
7987 if (!args) SWIG_fail;
7988 swig_obj[0] = args;
7989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
7990 if (!SWIG_IsOK(res1)) {
7991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ToolTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
7992 }
7993 arg1 = reinterpret_cast< wxToolTip * >(argp1);
7994 {
7995 PyThreadState* __tstate = wxPyBeginAllowThreads();
7996 delete arg1;
7997
7998 wxPyEndAllowThreads(__tstate);
7999 if (PyErr_Occurred()) SWIG_fail;
8000 }
8001 resultobj = SWIG_Py_Void();
8002 return resultobj;
8003 fail:
8004 return NULL;
8005 }
8006
8007
8008 SWIGINTERN PyObject *_wrap_ToolTip_SetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8009 PyObject *resultobj = 0;
8010 wxToolTip *arg1 = (wxToolTip *) 0 ;
8011 wxString *arg2 = 0 ;
8012 void *argp1 = 0 ;
8013 int res1 = 0 ;
8014 bool temp2 = false ;
8015 PyObject * obj0 = 0 ;
8016 PyObject * obj1 = 0 ;
8017 char * kwnames[] = {
8018 (char *) "self",(char *) "tip", NULL
8019 };
8020
8021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) SWIG_fail;
8022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8023 if (!SWIG_IsOK(res1)) {
8024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_SetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8025 }
8026 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8027 {
8028 arg2 = wxString_in_helper(obj1);
8029 if (arg2 == NULL) SWIG_fail;
8030 temp2 = true;
8031 }
8032 {
8033 PyThreadState* __tstate = wxPyBeginAllowThreads();
8034 (arg1)->SetTip((wxString const &)*arg2);
8035 wxPyEndAllowThreads(__tstate);
8036 if (PyErr_Occurred()) SWIG_fail;
8037 }
8038 resultobj = SWIG_Py_Void();
8039 {
8040 if (temp2)
8041 delete arg2;
8042 }
8043 return resultobj;
8044 fail:
8045 {
8046 if (temp2)
8047 delete arg2;
8048 }
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_ToolTip_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055 wxToolTip *arg1 = (wxToolTip *) 0 ;
8056 wxString result;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 PyObject *swig_obj[1] ;
8060
8061 if (!args) SWIG_fail;
8062 swig_obj[0] = args;
8063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetTip" "', expected argument " "1"" of type '" "wxToolTip *""'");
8066 }
8067 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 result = (arg1)->GetTip();
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 {
8075 #if wxUSE_UNICODE
8076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8077 #else
8078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8079 #endif
8080 }
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 SWIGINTERN PyObject *_wrap_ToolTip_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8088 PyObject *resultobj = 0;
8089 wxToolTip *arg1 = (wxToolTip *) 0 ;
8090 wxWindow *result = 0 ;
8091 void *argp1 = 0 ;
8092 int res1 = 0 ;
8093 PyObject *swig_obj[1] ;
8094
8095 if (!args) SWIG_fail;
8096 swig_obj[0] = args;
8097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxToolTip, 0 | 0 );
8098 if (!SWIG_IsOK(res1)) {
8099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ToolTip_GetWindow" "', expected argument " "1"" of type '" "wxToolTip *""'");
8100 }
8101 arg1 = reinterpret_cast< wxToolTip * >(argp1);
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 result = (wxWindow *)(arg1)->GetWindow();
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 {
8109 resultobj = wxPyMake_wxObject(result, 0);
8110 }
8111 return resultobj;
8112 fail:
8113 return NULL;
8114 }
8115
8116
8117 SWIGINTERN PyObject *_wrap_ToolTip_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8118 PyObject *resultobj = 0;
8119 bool arg1 ;
8120 bool val1 ;
8121 int ecode1 = 0 ;
8122 PyObject * obj0 = 0 ;
8123 char * kwnames[] = {
8124 (char *) "flag", NULL
8125 };
8126
8127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) SWIG_fail;
8128 ecode1 = SWIG_AsVal_bool(obj0, &val1);
8129 if (!SWIG_IsOK(ecode1)) {
8130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_Enable" "', expected argument " "1"" of type '" "bool""'");
8131 }
8132 arg1 = static_cast< bool >(val1);
8133 {
8134 PyThreadState* __tstate = wxPyBeginAllowThreads();
8135 wxToolTip::Enable(arg1);
8136 wxPyEndAllowThreads(__tstate);
8137 if (PyErr_Occurred()) SWIG_fail;
8138 }
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_ToolTip_SetDelay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8147 PyObject *resultobj = 0;
8148 long arg1 ;
8149 long val1 ;
8150 int ecode1 = 0 ;
8151 PyObject * obj0 = 0 ;
8152 char * kwnames[] = {
8153 (char *) "milliseconds", NULL
8154 };
8155
8156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) SWIG_fail;
8157 ecode1 = SWIG_AsVal_long(obj0, &val1);
8158 if (!SWIG_IsOK(ecode1)) {
8159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ToolTip_SetDelay" "', expected argument " "1"" of type '" "long""'");
8160 }
8161 arg1 = static_cast< long >(val1);
8162 {
8163 PyThreadState* __tstate = wxPyBeginAllowThreads();
8164 wxToolTip::SetDelay(arg1);
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 resultobj = SWIG_Py_Void();
8169 return resultobj;
8170 fail:
8171 return NULL;
8172 }
8173
8174
8175 SWIGINTERN PyObject *ToolTip_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8176 PyObject *obj;
8177 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8178 SWIG_TypeNewClientData(SWIGTYPE_p_wxToolTip, SWIG_NewClientData(obj));
8179 return SWIG_Py_Void();
8180 }
8181
8182 SWIGINTERN PyObject *ToolTip_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8183 return SWIG_Python_InitShadowInstance(args);
8184 }
8185
8186 SWIGINTERN PyObject *_wrap_new_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8187 PyObject *resultobj = 0;
8188 wxWindow *arg1 = (wxWindow *) 0 ;
8189 wxSize *arg2 = 0 ;
8190 wxCaret *result = 0 ;
8191 void *argp1 = 0 ;
8192 int res1 = 0 ;
8193 wxSize temp2 ;
8194 PyObject * obj0 = 0 ;
8195 PyObject * obj1 = 0 ;
8196 char * kwnames[] = {
8197 (char *) "window",(char *) "size", NULL
8198 };
8199
8200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) SWIG_fail;
8201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8202 if (!SWIG_IsOK(res1)) {
8203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Caret" "', expected argument " "1"" of type '" "wxWindow *""'");
8204 }
8205 arg1 = reinterpret_cast< wxWindow * >(argp1);
8206 {
8207 arg2 = &temp2;
8208 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8209 }
8210 {
8211 if (!wxPyCheckForApp()) SWIG_fail;
8212 PyThreadState* __tstate = wxPyBeginAllowThreads();
8213 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
8214 wxPyEndAllowThreads(__tstate);
8215 if (PyErr_Occurred()) SWIG_fail;
8216 }
8217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, SWIG_POINTER_NEW | 0 );
8218 return resultobj;
8219 fail:
8220 return NULL;
8221 }
8222
8223
8224 SWIGINTERN PyObject *_wrap_delete_Caret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8225 PyObject *resultobj = 0;
8226 wxCaret *arg1 = (wxCaret *) 0 ;
8227 void *argp1 = 0 ;
8228 int res1 = 0 ;
8229 PyObject *swig_obj[1] ;
8230
8231 if (!args) SWIG_fail;
8232 swig_obj[0] = args;
8233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
8234 if (!SWIG_IsOK(res1)) {
8235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Caret" "', expected argument " "1"" of type '" "wxCaret *""'");
8236 }
8237 arg1 = reinterpret_cast< wxCaret * >(argp1);
8238 {
8239 PyThreadState* __tstate = wxPyBeginAllowThreads();
8240 delete arg1;
8241
8242 wxPyEndAllowThreads(__tstate);
8243 if (PyErr_Occurred()) SWIG_fail;
8244 }
8245 resultobj = SWIG_Py_Void();
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 SWIGINTERN PyObject *_wrap_Caret_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8253 PyObject *resultobj = 0;
8254 wxCaret *arg1 = (wxCaret *) 0 ;
8255 void *argp1 = 0 ;
8256 int res1 = 0 ;
8257 PyObject *swig_obj[1] ;
8258
8259 if (!args) SWIG_fail;
8260 swig_obj[0] = args;
8261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8262 if (!SWIG_IsOK(res1)) {
8263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Destroy" "', expected argument " "1"" of type '" "wxCaret *""'");
8264 }
8265 arg1 = reinterpret_cast< wxCaret * >(argp1);
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 wxCaret_Destroy(arg1);
8269 wxPyEndAllowThreads(__tstate);
8270 if (PyErr_Occurred()) SWIG_fail;
8271 }
8272 resultobj = SWIG_Py_Void();
8273 return resultobj;
8274 fail:
8275 return NULL;
8276 }
8277
8278
8279 SWIGINTERN PyObject *_wrap_Caret_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8280 PyObject *resultobj = 0;
8281 wxCaret *arg1 = (wxCaret *) 0 ;
8282 bool result;
8283 void *argp1 = 0 ;
8284 int res1 = 0 ;
8285 PyObject *swig_obj[1] ;
8286
8287 if (!args) SWIG_fail;
8288 swig_obj[0] = args;
8289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8290 if (!SWIG_IsOK(res1)) {
8291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsOk" "', expected argument " "1"" of type '" "wxCaret *""'");
8292 }
8293 arg1 = reinterpret_cast< wxCaret * >(argp1);
8294 {
8295 PyThreadState* __tstate = wxPyBeginAllowThreads();
8296 result = (bool)(arg1)->IsOk();
8297 wxPyEndAllowThreads(__tstate);
8298 if (PyErr_Occurred()) SWIG_fail;
8299 }
8300 {
8301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8302 }
8303 return resultobj;
8304 fail:
8305 return NULL;
8306 }
8307
8308
8309 SWIGINTERN PyObject *_wrap_Caret_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8310 PyObject *resultobj = 0;
8311 wxCaret *arg1 = (wxCaret *) 0 ;
8312 bool result;
8313 void *argp1 = 0 ;
8314 int res1 = 0 ;
8315 PyObject *swig_obj[1] ;
8316
8317 if (!args) SWIG_fail;
8318 swig_obj[0] = args;
8319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8320 if (!SWIG_IsOK(res1)) {
8321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_IsVisible" "', expected argument " "1"" of type '" "wxCaret *""'");
8322 }
8323 arg1 = reinterpret_cast< wxCaret * >(argp1);
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (bool)(arg1)->IsVisible();
8327 wxPyEndAllowThreads(__tstate);
8328 if (PyErr_Occurred()) SWIG_fail;
8329 }
8330 {
8331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8332 }
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_Caret_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8340 PyObject *resultobj = 0;
8341 wxCaret *arg1 = (wxCaret *) 0 ;
8342 wxPoint result;
8343 void *argp1 = 0 ;
8344 int res1 = 0 ;
8345 PyObject *swig_obj[1] ;
8346
8347 if (!args) SWIG_fail;
8348 swig_obj[0] = args;
8349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8350 if (!SWIG_IsOK(res1)) {
8351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPosition" "', expected argument " "1"" of type '" "wxCaret *""'");
8352 }
8353 arg1 = reinterpret_cast< wxCaret * >(argp1);
8354 {
8355 PyThreadState* __tstate = wxPyBeginAllowThreads();
8356 result = (arg1)->GetPosition();
8357 wxPyEndAllowThreads(__tstate);
8358 if (PyErr_Occurred()) SWIG_fail;
8359 }
8360 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
8361 return resultobj;
8362 fail:
8363 return NULL;
8364 }
8365
8366
8367 SWIGINTERN PyObject *_wrap_Caret_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8368 PyObject *resultobj = 0;
8369 wxCaret *arg1 = (wxCaret *) 0 ;
8370 int *arg2 = (int *) 0 ;
8371 int *arg3 = (int *) 0 ;
8372 void *argp1 = 0 ;
8373 int res1 = 0 ;
8374 int temp2 ;
8375 int res2 = SWIG_TMPOBJ ;
8376 int temp3 ;
8377 int res3 = SWIG_TMPOBJ ;
8378 PyObject *swig_obj[1] ;
8379
8380 arg2 = &temp2;
8381 arg3 = &temp3;
8382 if (!args) SWIG_fail;
8383 swig_obj[0] = args;
8384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8385 if (!SWIG_IsOK(res1)) {
8386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetPositionTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8387 }
8388 arg1 = reinterpret_cast< wxCaret * >(argp1);
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 (arg1)->GetPosition(arg2,arg3);
8392 wxPyEndAllowThreads(__tstate);
8393 if (PyErr_Occurred()) SWIG_fail;
8394 }
8395 resultobj = SWIG_Py_Void();
8396 if (SWIG_IsTmpObj(res2)) {
8397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8398 } else {
8399 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8401 }
8402 if (SWIG_IsTmpObj(res3)) {
8403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8404 } else {
8405 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8407 }
8408 return resultobj;
8409 fail:
8410 return NULL;
8411 }
8412
8413
8414 SWIGINTERN PyObject *_wrap_Caret_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8415 PyObject *resultobj = 0;
8416 wxCaret *arg1 = (wxCaret *) 0 ;
8417 wxSize result;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 PyObject *swig_obj[1] ;
8421
8422 if (!args) SWIG_fail;
8423 swig_obj[0] = args;
8424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8425 if (!SWIG_IsOK(res1)) {
8426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8427 }
8428 arg1 = reinterpret_cast< wxCaret * >(argp1);
8429 {
8430 PyThreadState* __tstate = wxPyBeginAllowThreads();
8431 result = (arg1)->GetSize();
8432 wxPyEndAllowThreads(__tstate);
8433 if (PyErr_Occurred()) SWIG_fail;
8434 }
8435 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
8436 return resultobj;
8437 fail:
8438 return NULL;
8439 }
8440
8441
8442 SWIGINTERN PyObject *_wrap_Caret_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8443 PyObject *resultobj = 0;
8444 wxCaret *arg1 = (wxCaret *) 0 ;
8445 int *arg2 = (int *) 0 ;
8446 int *arg3 = (int *) 0 ;
8447 void *argp1 = 0 ;
8448 int res1 = 0 ;
8449 int temp2 ;
8450 int res2 = SWIG_TMPOBJ ;
8451 int temp3 ;
8452 int res3 = SWIG_TMPOBJ ;
8453 PyObject *swig_obj[1] ;
8454
8455 arg2 = &temp2;
8456 arg3 = &temp3;
8457 if (!args) SWIG_fail;
8458 swig_obj[0] = args;
8459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8460 if (!SWIG_IsOK(res1)) {
8461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetSizeTuple" "', expected argument " "1"" of type '" "wxCaret *""'");
8462 }
8463 arg1 = reinterpret_cast< wxCaret * >(argp1);
8464 {
8465 PyThreadState* __tstate = wxPyBeginAllowThreads();
8466 (arg1)->GetSize(arg2,arg3);
8467 wxPyEndAllowThreads(__tstate);
8468 if (PyErr_Occurred()) SWIG_fail;
8469 }
8470 resultobj = SWIG_Py_Void();
8471 if (SWIG_IsTmpObj(res2)) {
8472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8473 } else {
8474 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8476 }
8477 if (SWIG_IsTmpObj(res3)) {
8478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8479 } else {
8480 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8482 }
8483 return resultobj;
8484 fail:
8485 return NULL;
8486 }
8487
8488
8489 SWIGINTERN PyObject *_wrap_Caret_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8490 PyObject *resultobj = 0;
8491 wxCaret *arg1 = (wxCaret *) 0 ;
8492 wxWindow *result = 0 ;
8493 void *argp1 = 0 ;
8494 int res1 = 0 ;
8495 PyObject *swig_obj[1] ;
8496
8497 if (!args) SWIG_fail;
8498 swig_obj[0] = args;
8499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8500 if (!SWIG_IsOK(res1)) {
8501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_GetWindow" "', expected argument " "1"" of type '" "wxCaret *""'");
8502 }
8503 arg1 = reinterpret_cast< wxCaret * >(argp1);
8504 {
8505 PyThreadState* __tstate = wxPyBeginAllowThreads();
8506 result = (wxWindow *)(arg1)->GetWindow();
8507 wxPyEndAllowThreads(__tstate);
8508 if (PyErr_Occurred()) SWIG_fail;
8509 }
8510 {
8511 resultobj = wxPyMake_wxObject(result, 0);
8512 }
8513 return resultobj;
8514 fail:
8515 return NULL;
8516 }
8517
8518
8519 SWIGINTERN PyObject *_wrap_Caret_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj = 0;
8521 wxCaret *arg1 = (wxCaret *) 0 ;
8522 int arg2 ;
8523 int arg3 ;
8524 void *argp1 = 0 ;
8525 int res1 = 0 ;
8526 int val2 ;
8527 int ecode2 = 0 ;
8528 int val3 ;
8529 int ecode3 = 0 ;
8530 PyObject * obj0 = 0 ;
8531 PyObject * obj1 = 0 ;
8532 PyObject * obj2 = 0 ;
8533 char * kwnames[] = {
8534 (char *) "self",(char *) "x",(char *) "y", NULL
8535 };
8536
8537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8539 if (!SWIG_IsOK(res1)) {
8540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_MoveXY" "', expected argument " "1"" of type '" "wxCaret *""'");
8541 }
8542 arg1 = reinterpret_cast< wxCaret * >(argp1);
8543 ecode2 = SWIG_AsVal_int(obj1, &val2);
8544 if (!SWIG_IsOK(ecode2)) {
8545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_MoveXY" "', expected argument " "2"" of type '" "int""'");
8546 }
8547 arg2 = static_cast< int >(val2);
8548 ecode3 = SWIG_AsVal_int(obj2, &val3);
8549 if (!SWIG_IsOK(ecode3)) {
8550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_MoveXY" "', expected argument " "3"" of type '" "int""'");
8551 }
8552 arg3 = static_cast< int >(val3);
8553 {
8554 PyThreadState* __tstate = wxPyBeginAllowThreads();
8555 (arg1)->Move(arg2,arg3);
8556 wxPyEndAllowThreads(__tstate);
8557 if (PyErr_Occurred()) SWIG_fail;
8558 }
8559 resultobj = SWIG_Py_Void();
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 SWIGINTERN PyObject *_wrap_Caret_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8567 PyObject *resultobj = 0;
8568 wxCaret *arg1 = (wxCaret *) 0 ;
8569 wxPoint *arg2 = 0 ;
8570 void *argp1 = 0 ;
8571 int res1 = 0 ;
8572 wxPoint temp2 ;
8573 PyObject * obj0 = 0 ;
8574 PyObject * obj1 = 0 ;
8575 char * kwnames[] = {
8576 (char *) "self",(char *) "pt", NULL
8577 };
8578
8579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) SWIG_fail;
8580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8581 if (!SWIG_IsOK(res1)) {
8582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Move" "', expected argument " "1"" of type '" "wxCaret *""'");
8583 }
8584 arg1 = reinterpret_cast< wxCaret * >(argp1);
8585 {
8586 arg2 = &temp2;
8587 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
8588 }
8589 {
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 (arg1)->Move((wxPoint const &)*arg2);
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 resultobj = SWIG_Py_Void();
8596 return resultobj;
8597 fail:
8598 return NULL;
8599 }
8600
8601
8602 SWIGINTERN PyObject *_wrap_Caret_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8603 PyObject *resultobj = 0;
8604 wxCaret *arg1 = (wxCaret *) 0 ;
8605 int arg2 ;
8606 int arg3 ;
8607 void *argp1 = 0 ;
8608 int res1 = 0 ;
8609 int val2 ;
8610 int ecode2 = 0 ;
8611 int val3 ;
8612 int ecode3 = 0 ;
8613 PyObject * obj0 = 0 ;
8614 PyObject * obj1 = 0 ;
8615 PyObject * obj2 = 0 ;
8616 char * kwnames[] = {
8617 (char *) "self",(char *) "width",(char *) "height", NULL
8618 };
8619
8620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8622 if (!SWIG_IsOK(res1)) {
8623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSizeWH" "', expected argument " "1"" of type '" "wxCaret *""'");
8624 }
8625 arg1 = reinterpret_cast< wxCaret * >(argp1);
8626 ecode2 = SWIG_AsVal_int(obj1, &val2);
8627 if (!SWIG_IsOK(ecode2)) {
8628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
8629 }
8630 arg2 = static_cast< int >(val2);
8631 ecode3 = SWIG_AsVal_int(obj2, &val3);
8632 if (!SWIG_IsOK(ecode3)) {
8633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Caret_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
8634 }
8635 arg3 = static_cast< int >(val3);
8636 {
8637 PyThreadState* __tstate = wxPyBeginAllowThreads();
8638 (arg1)->SetSize(arg2,arg3);
8639 wxPyEndAllowThreads(__tstate);
8640 if (PyErr_Occurred()) SWIG_fail;
8641 }
8642 resultobj = SWIG_Py_Void();
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Caret_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8650 PyObject *resultobj = 0;
8651 wxCaret *arg1 = (wxCaret *) 0 ;
8652 wxSize *arg2 = 0 ;
8653 void *argp1 = 0 ;
8654 int res1 = 0 ;
8655 wxSize temp2 ;
8656 PyObject * obj0 = 0 ;
8657 PyObject * obj1 = 0 ;
8658 char * kwnames[] = {
8659 (char *) "self",(char *) "size", NULL
8660 };
8661
8662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
8663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_SetSize" "', expected argument " "1"" of type '" "wxCaret *""'");
8666 }
8667 arg1 = reinterpret_cast< wxCaret * >(argp1);
8668 {
8669 arg2 = &temp2;
8670 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
8671 }
8672 {
8673 PyThreadState* __tstate = wxPyBeginAllowThreads();
8674 (arg1)->SetSize((wxSize const &)*arg2);
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 resultobj = SWIG_Py_Void();
8679 return resultobj;
8680 fail:
8681 return NULL;
8682 }
8683
8684
8685 SWIGINTERN PyObject *_wrap_Caret_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8686 PyObject *resultobj = 0;
8687 wxCaret *arg1 = (wxCaret *) 0 ;
8688 int arg2 = (int) true ;
8689 void *argp1 = 0 ;
8690 int res1 = 0 ;
8691 int val2 ;
8692 int ecode2 = 0 ;
8693 PyObject * obj0 = 0 ;
8694 PyObject * obj1 = 0 ;
8695 char * kwnames[] = {
8696 (char *) "self",(char *) "show", NULL
8697 };
8698
8699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) SWIG_fail;
8700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8701 if (!SWIG_IsOK(res1)) {
8702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Show" "', expected argument " "1"" of type '" "wxCaret *""'");
8703 }
8704 arg1 = reinterpret_cast< wxCaret * >(argp1);
8705 if (obj1) {
8706 ecode2 = SWIG_AsVal_int(obj1, &val2);
8707 if (!SWIG_IsOK(ecode2)) {
8708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Caret_Show" "', expected argument " "2"" of type '" "int""'");
8709 }
8710 arg2 = static_cast< int >(val2);
8711 }
8712 {
8713 PyThreadState* __tstate = wxPyBeginAllowThreads();
8714 (arg1)->Show(arg2);
8715 wxPyEndAllowThreads(__tstate);
8716 if (PyErr_Occurred()) SWIG_fail;
8717 }
8718 resultobj = SWIG_Py_Void();
8719 return resultobj;
8720 fail:
8721 return NULL;
8722 }
8723
8724
8725 SWIGINTERN PyObject *_wrap_Caret_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8726 PyObject *resultobj = 0;
8727 wxCaret *arg1 = (wxCaret *) 0 ;
8728 void *argp1 = 0 ;
8729 int res1 = 0 ;
8730 PyObject *swig_obj[1] ;
8731
8732 if (!args) SWIG_fail;
8733 swig_obj[0] = args;
8734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCaret, 0 | 0 );
8735 if (!SWIG_IsOK(res1)) {
8736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Caret_Hide" "', expected argument " "1"" of type '" "wxCaret *""'");
8737 }
8738 arg1 = reinterpret_cast< wxCaret * >(argp1);
8739 {
8740 PyThreadState* __tstate = wxPyBeginAllowThreads();
8741 (arg1)->Hide();
8742 wxPyEndAllowThreads(__tstate);
8743 if (PyErr_Occurred()) SWIG_fail;
8744 }
8745 resultobj = SWIG_Py_Void();
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 SWIGINTERN PyObject *_wrap_Caret_GetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8753 PyObject *resultobj = 0;
8754 int result;
8755
8756 if (!SWIG_Python_UnpackTuple(args,"Caret_GetBlinkTime",0,0,0)) SWIG_fail;
8757 {
8758 PyThreadState* __tstate = wxPyBeginAllowThreads();
8759 result = (int)wxCaret::GetBlinkTime();
8760 wxPyEndAllowThreads(__tstate);
8761 if (PyErr_Occurred()) SWIG_fail;
8762 }
8763 resultobj = SWIG_From_int(static_cast< int >(result));
8764 return resultobj;
8765 fail:
8766 return NULL;
8767 }
8768
8769
8770 SWIGINTERN PyObject *_wrap_Caret_SetBlinkTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8771 PyObject *resultobj = 0;
8772 int arg1 ;
8773 int val1 ;
8774 int ecode1 = 0 ;
8775 PyObject * obj0 = 0 ;
8776 char * kwnames[] = {
8777 (char *) "milliseconds", NULL
8778 };
8779
8780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) SWIG_fail;
8781 ecode1 = SWIG_AsVal_int(obj0, &val1);
8782 if (!SWIG_IsOK(ecode1)) {
8783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Caret_SetBlinkTime" "', expected argument " "1"" of type '" "int""'");
8784 }
8785 arg1 = static_cast< int >(val1);
8786 {
8787 PyThreadState* __tstate = wxPyBeginAllowThreads();
8788 wxCaret::SetBlinkTime(arg1);
8789 wxPyEndAllowThreads(__tstate);
8790 if (PyErr_Occurred()) SWIG_fail;
8791 }
8792 resultobj = SWIG_Py_Void();
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *Caret_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 PyObject *obj;
8801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8802 SWIG_TypeNewClientData(SWIGTYPE_p_wxCaret, SWIG_NewClientData(obj));
8803 return SWIG_Py_Void();
8804 }
8805
8806 SWIGINTERN PyObject *Caret_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8807 return SWIG_Python_InitShadowInstance(args);
8808 }
8809
8810 SWIGINTERN PyObject *_wrap_new_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj = 0;
8812 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
8813 wxBusyCursor *result = 0 ;
8814 void *argp1 = 0 ;
8815 int res1 = 0 ;
8816 PyObject * obj0 = 0 ;
8817 char * kwnames[] = {
8818 (char *) "cursor", NULL
8819 };
8820
8821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) SWIG_fail;
8822 if (obj0) {
8823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCursor, 0 | 0 );
8824 if (!SWIG_IsOK(res1)) {
8825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BusyCursor" "', expected argument " "1"" of type '" "wxCursor *""'");
8826 }
8827 arg1 = reinterpret_cast< wxCursor * >(argp1);
8828 }
8829 {
8830 if (!wxPyCheckForApp()) SWIG_fail;
8831 PyThreadState* __tstate = wxPyBeginAllowThreads();
8832 result = (wxBusyCursor *)new wxBusyCursor(arg1);
8833 wxPyEndAllowThreads(__tstate);
8834 if (PyErr_Occurred()) SWIG_fail;
8835 }
8836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_NEW | 0 );
8837 return resultobj;
8838 fail:
8839 return NULL;
8840 }
8841
8842
8843 SWIGINTERN PyObject *_wrap_delete_BusyCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8844 PyObject *resultobj = 0;
8845 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
8846 void *argp1 = 0 ;
8847 int res1 = 0 ;
8848 PyObject *swig_obj[1] ;
8849
8850 if (!args) SWIG_fail;
8851 swig_obj[0] = args;
8852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_DISOWN | 0 );
8853 if (!SWIG_IsOK(res1)) {
8854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyCursor" "', expected argument " "1"" of type '" "wxBusyCursor *""'");
8855 }
8856 arg1 = reinterpret_cast< wxBusyCursor * >(argp1);
8857 {
8858 PyThreadState* __tstate = wxPyBeginAllowThreads();
8859 delete arg1;
8860
8861 wxPyEndAllowThreads(__tstate);
8862 if (PyErr_Occurred()) SWIG_fail;
8863 }
8864 resultobj = SWIG_Py_Void();
8865 return resultobj;
8866 fail:
8867 return NULL;
8868 }
8869
8870
8871 SWIGINTERN PyObject *BusyCursor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8872 PyObject *obj;
8873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8874 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyCursor, SWIG_NewClientData(obj));
8875 return SWIG_Py_Void();
8876 }
8877
8878 SWIGINTERN PyObject *BusyCursor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8879 return SWIG_Python_InitShadowInstance(args);
8880 }
8881
8882 SWIGINTERN PyObject *_wrap_new_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8883 PyObject *resultobj = 0;
8884 wxWindow *arg1 = (wxWindow *) NULL ;
8885 wxWindowDisabler *result = 0 ;
8886 void *argp1 = 0 ;
8887 int res1 = 0 ;
8888 PyObject * obj0 = 0 ;
8889 char * kwnames[] = {
8890 (char *) "winToSkip", NULL
8891 };
8892
8893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) SWIG_fail;
8894 if (obj0) {
8895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
8896 if (!SWIG_IsOK(res1)) {
8897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDisabler" "', expected argument " "1"" of type '" "wxWindow *""'");
8898 }
8899 arg1 = reinterpret_cast< wxWindow * >(argp1);
8900 }
8901 {
8902 if (!wxPyCheckForApp()) SWIG_fail;
8903 PyThreadState* __tstate = wxPyBeginAllowThreads();
8904 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
8905 wxPyEndAllowThreads(__tstate);
8906 if (PyErr_Occurred()) SWIG_fail;
8907 }
8908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_NEW | 0 );
8909 return resultobj;
8910 fail:
8911 return NULL;
8912 }
8913
8914
8915 SWIGINTERN PyObject *_wrap_delete_WindowDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8916 PyObject *resultobj = 0;
8917 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
8918 void *argp1 = 0 ;
8919 int res1 = 0 ;
8920 PyObject *swig_obj[1] ;
8921
8922 if (!args) SWIG_fail;
8923 swig_obj[0] = args;
8924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_DISOWN | 0 );
8925 if (!SWIG_IsOK(res1)) {
8926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WindowDisabler" "', expected argument " "1"" of type '" "wxWindowDisabler *""'");
8927 }
8928 arg1 = reinterpret_cast< wxWindowDisabler * >(argp1);
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 delete arg1;
8932
8933 wxPyEndAllowThreads(__tstate);
8934 if (PyErr_Occurred()) SWIG_fail;
8935 }
8936 resultobj = SWIG_Py_Void();
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 SWIGINTERN PyObject *WindowDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8944 PyObject *obj;
8945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8946 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDisabler, SWIG_NewClientData(obj));
8947 return SWIG_Py_Void();
8948 }
8949
8950 SWIGINTERN PyObject *WindowDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8951 return SWIG_Python_InitShadowInstance(args);
8952 }
8953
8954 SWIGINTERN PyObject *_wrap_new_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj = 0;
8956 wxString *arg1 = 0 ;
8957 wxBusyInfo *result = 0 ;
8958 bool temp1 = false ;
8959 PyObject * obj0 = 0 ;
8960 char * kwnames[] = {
8961 (char *) "message", NULL
8962 };
8963
8964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) SWIG_fail;
8965 {
8966 arg1 = wxString_in_helper(obj0);
8967 if (arg1 == NULL) SWIG_fail;
8968 temp1 = true;
8969 }
8970 {
8971 if (!wxPyCheckForApp()) SWIG_fail;
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_NEW | 0 );
8978 {
8979 if (temp1)
8980 delete arg1;
8981 }
8982 return resultobj;
8983 fail:
8984 {
8985 if (temp1)
8986 delete arg1;
8987 }
8988 return NULL;
8989 }
8990
8991
8992 SWIGINTERN PyObject *_wrap_delete_BusyInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8993 PyObject *resultobj = 0;
8994 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
8995 void *argp1 = 0 ;
8996 int res1 = 0 ;
8997 PyObject *swig_obj[1] ;
8998
8999 if (!args) SWIG_fail;
9000 swig_obj[0] = args;
9001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_DISOWN | 0 );
9002 if (!SWIG_IsOK(res1)) {
9003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BusyInfo" "', expected argument " "1"" of type '" "wxBusyInfo *""'");
9004 }
9005 arg1 = reinterpret_cast< wxBusyInfo * >(argp1);
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 delete arg1;
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 resultobj = SWIG_Py_Void();
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 SWIGINTERN PyObject *BusyInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9021 PyObject *obj;
9022 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9023 SWIG_TypeNewClientData(SWIGTYPE_p_wxBusyInfo, SWIG_NewClientData(obj));
9024 return SWIG_Py_Void();
9025 }
9026
9027 SWIGINTERN PyObject *BusyInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9028 return SWIG_Python_InitShadowInstance(args);
9029 }
9030
9031 SWIGINTERN PyObject *_wrap_new_StopWatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9032 PyObject *resultobj = 0;
9033 wxStopWatch *result = 0 ;
9034
9035 if (!SWIG_Python_UnpackTuple(args,"new_StopWatch",0,0,0)) SWIG_fail;
9036 {
9037 PyThreadState* __tstate = wxPyBeginAllowThreads();
9038 result = (wxStopWatch *)new wxStopWatch();
9039 wxPyEndAllowThreads(__tstate);
9040 if (PyErr_Occurred()) SWIG_fail;
9041 }
9042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStopWatch, SWIG_POINTER_NEW | 0 );
9043 return resultobj;
9044 fail:
9045 return NULL;
9046 }
9047
9048
9049 SWIGINTERN PyObject *_wrap_StopWatch_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9050 PyObject *resultobj = 0;
9051 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9052 long arg2 = (long) 0 ;
9053 void *argp1 = 0 ;
9054 int res1 = 0 ;
9055 long val2 ;
9056 int ecode2 = 0 ;
9057 PyObject * obj0 = 0 ;
9058 PyObject * obj1 = 0 ;
9059 char * kwnames[] = {
9060 (char *) "self",(char *) "t0", NULL
9061 };
9062
9063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) SWIG_fail;
9064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9065 if (!SWIG_IsOK(res1)) {
9066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Start" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9067 }
9068 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9069 if (obj1) {
9070 ecode2 = SWIG_AsVal_long(obj1, &val2);
9071 if (!SWIG_IsOK(ecode2)) {
9072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StopWatch_Start" "', expected argument " "2"" of type '" "long""'");
9073 }
9074 arg2 = static_cast< long >(val2);
9075 }
9076 {
9077 PyThreadState* __tstate = wxPyBeginAllowThreads();
9078 (arg1)->Start(arg2);
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 resultobj = SWIG_Py_Void();
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 SWIGINTERN PyObject *_wrap_StopWatch_Pause(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9090 PyObject *resultobj = 0;
9091 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9092 void *argp1 = 0 ;
9093 int res1 = 0 ;
9094 PyObject *swig_obj[1] ;
9095
9096 if (!args) SWIG_fail;
9097 swig_obj[0] = args;
9098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9099 if (!SWIG_IsOK(res1)) {
9100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Pause" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9101 }
9102 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9103 {
9104 PyThreadState* __tstate = wxPyBeginAllowThreads();
9105 (arg1)->Pause();
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 resultobj = SWIG_Py_Void();
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 SWIGINTERN PyObject *_wrap_StopWatch_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9117 PyObject *resultobj = 0;
9118 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9119 void *argp1 = 0 ;
9120 int res1 = 0 ;
9121 PyObject *swig_obj[1] ;
9122
9123 if (!args) SWIG_fail;
9124 swig_obj[0] = args;
9125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9126 if (!SWIG_IsOK(res1)) {
9127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Resume" "', expected argument " "1"" of type '" "wxStopWatch *""'");
9128 }
9129 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9130 {
9131 PyThreadState* __tstate = wxPyBeginAllowThreads();
9132 (arg1)->Resume();
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 resultobj = SWIG_Py_Void();
9137 return resultobj;
9138 fail:
9139 return NULL;
9140 }
9141
9142
9143 SWIGINTERN PyObject *_wrap_StopWatch_Time(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9144 PyObject *resultobj = 0;
9145 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
9146 long result;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 PyObject *swig_obj[1] ;
9150
9151 if (!args) SWIG_fail;
9152 swig_obj[0] = args;
9153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStopWatch, 0 | 0 );
9154 if (!SWIG_IsOK(res1)) {
9155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StopWatch_Time" "', expected argument " "1"" of type '" "wxStopWatch const *""'");
9156 }
9157 arg1 = reinterpret_cast< wxStopWatch * >(argp1);
9158 {
9159 PyThreadState* __tstate = wxPyBeginAllowThreads();
9160 result = (long)((wxStopWatch const *)arg1)->Time();
9161 wxPyEndAllowThreads(__tstate);
9162 if (PyErr_Occurred()) SWIG_fail;
9163 }
9164 resultobj = SWIG_From_long(static_cast< long >(result));
9165 return resultobj;
9166 fail:
9167 return NULL;
9168 }
9169
9170
9171 SWIGINTERN PyObject *StopWatch_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9172 PyObject *obj;
9173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9174 SWIG_TypeNewClientData(SWIGTYPE_p_wxStopWatch, SWIG_NewClientData(obj));
9175 return SWIG_Py_Void();
9176 }
9177
9178 SWIGINTERN PyObject *StopWatch_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 return SWIG_Python_InitShadowInstance(args);
9180 }
9181
9182 SWIGINTERN PyObject *_wrap_new_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9183 PyObject *resultobj = 0;
9184 int arg1 = (int) 9 ;
9185 int arg2 = (int) wxID_FILE1 ;
9186 wxFileHistory *result = 0 ;
9187 int val1 ;
9188 int ecode1 = 0 ;
9189 int val2 ;
9190 int ecode2 = 0 ;
9191 PyObject * obj0 = 0 ;
9192 PyObject * obj1 = 0 ;
9193 char * kwnames[] = {
9194 (char *) "maxFiles",(char *) "idBase", NULL
9195 };
9196
9197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9198 if (obj0) {
9199 ecode1 = SWIG_AsVal_int(obj0, &val1);
9200 if (!SWIG_IsOK(ecode1)) {
9201 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FileHistory" "', expected argument " "1"" of type '" "int""'");
9202 }
9203 arg1 = static_cast< int >(val1);
9204 }
9205 if (obj1) {
9206 ecode2 = SWIG_AsVal_int(obj1, &val2);
9207 if (!SWIG_IsOK(ecode2)) {
9208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FileHistory" "', expected argument " "2"" of type '" "int""'");
9209 }
9210 arg2 = static_cast< int >(val2);
9211 }
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileHistory, SWIG_POINTER_NEW | 0 );
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *_wrap_delete_FileHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226 PyObject *resultobj = 0;
9227 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9228 void *argp1 = 0 ;
9229 int res1 = 0 ;
9230 PyObject *swig_obj[1] ;
9231
9232 if (!args) SWIG_fail;
9233 swig_obj[0] = args;
9234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, SWIG_POINTER_DISOWN | 0 );
9235 if (!SWIG_IsOK(res1)) {
9236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9237 }
9238 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9239 {
9240 PyThreadState* __tstate = wxPyBeginAllowThreads();
9241 delete arg1;
9242
9243 wxPyEndAllowThreads(__tstate);
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 resultobj = SWIG_Py_Void();
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 SWIGINTERN PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9254 PyObject *resultobj = 0;
9255 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9256 wxString *arg2 = 0 ;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 bool temp2 = false ;
9260 PyObject * obj0 = 0 ;
9261 PyObject * obj1 = 0 ;
9262 char * kwnames[] = {
9263 (char *) "self",(char *) "file", NULL
9264 };
9265
9266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9268 if (!SWIG_IsOK(res1)) {
9269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFileToHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9270 }
9271 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9272 {
9273 arg2 = wxString_in_helper(obj1);
9274 if (arg2 == NULL) SWIG_fail;
9275 temp2 = true;
9276 }
9277 {
9278 PyThreadState* __tstate = wxPyBeginAllowThreads();
9279 (arg1)->AddFileToHistory((wxString const &)*arg2);
9280 wxPyEndAllowThreads(__tstate);
9281 if (PyErr_Occurred()) SWIG_fail;
9282 }
9283 resultobj = SWIG_Py_Void();
9284 {
9285 if (temp2)
9286 delete arg2;
9287 }
9288 return resultobj;
9289 fail:
9290 {
9291 if (temp2)
9292 delete arg2;
9293 }
9294 return NULL;
9295 }
9296
9297
9298 SWIGINTERN PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9299 PyObject *resultobj = 0;
9300 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9301 int arg2 ;
9302 void *argp1 = 0 ;
9303 int res1 = 0 ;
9304 int val2 ;
9305 int ecode2 = 0 ;
9306 PyObject * obj0 = 0 ;
9307 PyObject * obj1 = 0 ;
9308 char * kwnames[] = {
9309 (char *) "self",(char *) "i", NULL
9310 };
9311
9312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) SWIG_fail;
9313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9314 if (!SWIG_IsOK(res1)) {
9315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9316 }
9317 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9318 ecode2 = SWIG_AsVal_int(obj1, &val2);
9319 if (!SWIG_IsOK(ecode2)) {
9320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_RemoveFileFromHistory" "', expected argument " "2"" of type '" "int""'");
9321 }
9322 arg2 = static_cast< int >(val2);
9323 {
9324 PyThreadState* __tstate = wxPyBeginAllowThreads();
9325 (arg1)->RemoveFileFromHistory(arg2);
9326 wxPyEndAllowThreads(__tstate);
9327 if (PyErr_Occurred()) SWIG_fail;
9328 }
9329 resultobj = SWIG_Py_Void();
9330 return resultobj;
9331 fail:
9332 return NULL;
9333 }
9334
9335
9336 SWIGINTERN PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9337 PyObject *resultobj = 0;
9338 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9339 int result;
9340 void *argp1 = 0 ;
9341 int res1 = 0 ;
9342 PyObject *swig_obj[1] ;
9343
9344 if (!args) SWIG_fail;
9345 swig_obj[0] = args;
9346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9347 if (!SWIG_IsOK(res1)) {
9348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetMaxFiles" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9349 }
9350 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9351 {
9352 PyThreadState* __tstate = wxPyBeginAllowThreads();
9353 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
9354 wxPyEndAllowThreads(__tstate);
9355 if (PyErr_Occurred()) SWIG_fail;
9356 }
9357 resultobj = SWIG_From_int(static_cast< int >(result));
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 SWIGINTERN PyObject *_wrap_FileHistory_UseMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9365 PyObject *resultobj = 0;
9366 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9367 wxMenu *arg2 = (wxMenu *) 0 ;
9368 void *argp1 = 0 ;
9369 int res1 = 0 ;
9370 void *argp2 = 0 ;
9371 int res2 = 0 ;
9372 PyObject * obj0 = 0 ;
9373 PyObject * obj1 = 0 ;
9374 char * kwnames[] = {
9375 (char *) "self",(char *) "menu", NULL
9376 };
9377
9378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9380 if (!SWIG_IsOK(res1)) {
9381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_UseMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9382 }
9383 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9385 if (!SWIG_IsOK(res2)) {
9386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_UseMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9387 }
9388 arg2 = reinterpret_cast< wxMenu * >(argp2);
9389 {
9390 PyThreadState* __tstate = wxPyBeginAllowThreads();
9391 (arg1)->UseMenu(arg2);
9392 wxPyEndAllowThreads(__tstate);
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 resultobj = SWIG_Py_Void();
9396 return resultobj;
9397 fail:
9398 return NULL;
9399 }
9400
9401
9402 SWIGINTERN PyObject *_wrap_FileHistory_RemoveMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9403 PyObject *resultobj = 0;
9404 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9405 wxMenu *arg2 = (wxMenu *) 0 ;
9406 void *argp1 = 0 ;
9407 int res1 = 0 ;
9408 void *argp2 = 0 ;
9409 int res2 = 0 ;
9410 PyObject * obj0 = 0 ;
9411 PyObject * obj1 = 0 ;
9412 char * kwnames[] = {
9413 (char *) "self",(char *) "menu", NULL
9414 };
9415
9416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9418 if (!SWIG_IsOK(res1)) {
9419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_RemoveMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9420 }
9421 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9422 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9423 if (!SWIG_IsOK(res2)) {
9424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_RemoveMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9425 }
9426 arg2 = reinterpret_cast< wxMenu * >(argp2);
9427 {
9428 PyThreadState* __tstate = wxPyBeginAllowThreads();
9429 (arg1)->RemoveMenu(arg2);
9430 wxPyEndAllowThreads(__tstate);
9431 if (PyErr_Occurred()) SWIG_fail;
9432 }
9433 resultobj = SWIG_Py_Void();
9434 return resultobj;
9435 fail:
9436 return NULL;
9437 }
9438
9439
9440 SWIGINTERN PyObject *_wrap_FileHistory_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9441 PyObject *resultobj = 0;
9442 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9443 wxConfigBase *arg2 = 0 ;
9444 void *argp1 = 0 ;
9445 int res1 = 0 ;
9446 void *argp2 = 0 ;
9447 int res2 = 0 ;
9448 PyObject * obj0 = 0 ;
9449 PyObject * obj1 = 0 ;
9450 char * kwnames[] = {
9451 (char *) "self",(char *) "config", NULL
9452 };
9453
9454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) SWIG_fail;
9455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9456 if (!SWIG_IsOK(res1)) {
9457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Load" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9458 }
9459 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9460 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9461 if (!SWIG_IsOK(res2)) {
9462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9463 }
9464 if (!argp2) {
9465 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Load" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9466 }
9467 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9468 {
9469 PyThreadState* __tstate = wxPyBeginAllowThreads();
9470 (arg1)->Load(*arg2);
9471 wxPyEndAllowThreads(__tstate);
9472 if (PyErr_Occurred()) SWIG_fail;
9473 }
9474 resultobj = SWIG_Py_Void();
9475 return resultobj;
9476 fail:
9477 return NULL;
9478 }
9479
9480
9481 SWIGINTERN PyObject *_wrap_FileHistory_Save(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9482 PyObject *resultobj = 0;
9483 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9484 wxConfigBase *arg2 = 0 ;
9485 void *argp1 = 0 ;
9486 int res1 = 0 ;
9487 void *argp2 = 0 ;
9488 int res2 = 0 ;
9489 PyObject * obj0 = 0 ;
9490 PyObject * obj1 = 0 ;
9491 char * kwnames[] = {
9492 (char *) "self",(char *) "config", NULL
9493 };
9494
9495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) SWIG_fail;
9496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9497 if (!SWIG_IsOK(res1)) {
9498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_Save" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9499 }
9500 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9501 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxConfigBase, 0 );
9502 if (!SWIG_IsOK(res2)) {
9503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9504 }
9505 if (!argp2) {
9506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileHistory_Save" "', expected argument " "2"" of type '" "wxConfigBase &""'");
9507 }
9508 arg2 = reinterpret_cast< wxConfigBase * >(argp2);
9509 {
9510 PyThreadState* __tstate = wxPyBeginAllowThreads();
9511 (arg1)->Save(*arg2);
9512 wxPyEndAllowThreads(__tstate);
9513 if (PyErr_Occurred()) SWIG_fail;
9514 }
9515 resultobj = SWIG_Py_Void();
9516 return resultobj;
9517 fail:
9518 return NULL;
9519 }
9520
9521
9522 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9523 PyObject *resultobj = 0;
9524 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9525 void *argp1 = 0 ;
9526 int res1 = 0 ;
9527 PyObject *swig_obj[1] ;
9528
9529 if (!args) SWIG_fail;
9530 swig_obj[0] = args;
9531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9534 }
9535 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 (arg1)->AddFilesToMenu();
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_Py_Void();
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
9549 SWIGINTERN PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9550 PyObject *resultobj = 0;
9551 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9552 wxMenu *arg2 = (wxMenu *) 0 ;
9553 void *argp1 = 0 ;
9554 int res1 = 0 ;
9555 void *argp2 = 0 ;
9556 int res2 = 0 ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 char * kwnames[] = {
9560 (char *) "self",(char *) "menu", NULL
9561 };
9562
9563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) SWIG_fail;
9564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9565 if (!SWIG_IsOK(res1)) {
9566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "1"" of type '" "wxFileHistory *""'");
9567 }
9568 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
9570 if (!SWIG_IsOK(res2)) {
9571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileHistory_AddFilesToThisMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
9572 }
9573 arg2 = reinterpret_cast< wxMenu * >(argp2);
9574 {
9575 PyThreadState* __tstate = wxPyBeginAllowThreads();
9576 (arg1)->AddFilesToMenu(arg2);
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_Py_Void();
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj = 0;
9589 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9590 int arg2 ;
9591 wxString result;
9592 void *argp1 = 0 ;
9593 int res1 = 0 ;
9594 int val2 ;
9595 int ecode2 = 0 ;
9596 PyObject * obj0 = 0 ;
9597 PyObject * obj1 = 0 ;
9598 char * kwnames[] = {
9599 (char *) "self",(char *) "i", NULL
9600 };
9601
9602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) SWIG_fail;
9603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9604 if (!SWIG_IsOK(res1)) {
9605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9606 }
9607 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9608 ecode2 = SWIG_AsVal_int(obj1, &val2);
9609 if (!SWIG_IsOK(ecode2)) {
9610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileHistory_GetHistoryFile" "', expected argument " "2"" of type '" "int""'");
9611 }
9612 arg2 = static_cast< int >(val2);
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
9616 wxPyEndAllowThreads(__tstate);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 {
9620 #if wxUSE_UNICODE
9621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9622 #else
9623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9624 #endif
9625 }
9626 return resultobj;
9627 fail:
9628 return NULL;
9629 }
9630
9631
9632 SWIGINTERN PyObject *_wrap_FileHistory_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9633 PyObject *resultobj = 0;
9634 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
9635 int result;
9636 void *argp1 = 0 ;
9637 int res1 = 0 ;
9638 PyObject *swig_obj[1] ;
9639
9640 if (!args) SWIG_fail;
9641 swig_obj[0] = args;
9642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileHistory, 0 | 0 );
9643 if (!SWIG_IsOK(res1)) {
9644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileHistory_GetCount" "', expected argument " "1"" of type '" "wxFileHistory const *""'");
9645 }
9646 arg1 = reinterpret_cast< wxFileHistory * >(argp1);
9647 {
9648 PyThreadState* __tstate = wxPyBeginAllowThreads();
9649 result = (int)((wxFileHistory const *)arg1)->GetCount();
9650 wxPyEndAllowThreads(__tstate);
9651 if (PyErr_Occurred()) SWIG_fail;
9652 }
9653 resultobj = SWIG_From_int(static_cast< int >(result));
9654 return resultobj;
9655 fail:
9656 return NULL;
9657 }
9658
9659
9660 SWIGINTERN PyObject *FileHistory_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9661 PyObject *obj;
9662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9663 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileHistory, SWIG_NewClientData(obj));
9664 return SWIG_Py_Void();
9665 }
9666
9667 SWIGINTERN PyObject *FileHistory_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9668 return SWIG_Python_InitShadowInstance(args);
9669 }
9670
9671 SWIGINTERN PyObject *_wrap_new_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9672 PyObject *resultobj = 0;
9673 wxString *arg1 = 0 ;
9674 wxString const &arg2_defvalue = wxPyEmptyString ;
9675 wxString *arg2 = (wxString *) &arg2_defvalue ;
9676 wxSingleInstanceChecker *result = 0 ;
9677 bool temp1 = false ;
9678 bool temp2 = false ;
9679 PyObject * obj0 = 0 ;
9680 PyObject * obj1 = 0 ;
9681 char * kwnames[] = {
9682 (char *) "name",(char *) "path", NULL
9683 };
9684
9685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) SWIG_fail;
9686 {
9687 arg1 = wxString_in_helper(obj0);
9688 if (arg1 == NULL) SWIG_fail;
9689 temp1 = true;
9690 }
9691 if (obj1) {
9692 {
9693 arg2 = wxString_in_helper(obj1);
9694 if (arg2 == NULL) SWIG_fail;
9695 temp2 = true;
9696 }
9697 }
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
9701 wxPyEndAllowThreads(__tstate);
9702 if (PyErr_Occurred()) SWIG_fail;
9703 }
9704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_NEW | 0 );
9705 {
9706 if (temp1)
9707 delete arg1;
9708 }
9709 {
9710 if (temp2)
9711 delete arg2;
9712 }
9713 return resultobj;
9714 fail:
9715 {
9716 if (temp1)
9717 delete arg1;
9718 }
9719 {
9720 if (temp2)
9721 delete arg2;
9722 }
9723 return NULL;
9724 }
9725
9726
9727 SWIGINTERN PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9728 PyObject *resultobj = 0;
9729 wxSingleInstanceChecker *result = 0 ;
9730
9731 if (!SWIG_Python_UnpackTuple(args,"new_PreSingleInstanceChecker",0,0,0)) SWIG_fail;
9732 {
9733 PyThreadState* __tstate = wxPyBeginAllowThreads();
9734 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
9735 wxPyEndAllowThreads(__tstate);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_OWN | 0 );
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_delete_SingleInstanceChecker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *resultobj = 0;
9747 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9748 void *argp1 = 0 ;
9749 int res1 = 0 ;
9750 PyObject *swig_obj[1] ;
9751
9752 if (!args) SWIG_fail;
9753 swig_obj[0] = args;
9754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_DISOWN | 0 );
9755 if (!SWIG_IsOK(res1)) {
9756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SingleInstanceChecker" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9757 }
9758 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9759 {
9760 PyThreadState* __tstate = wxPyBeginAllowThreads();
9761 delete arg1;
9762
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 resultobj = SWIG_Py_Void();
9767 return resultobj;
9768 fail:
9769 return NULL;
9770 }
9771
9772
9773 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9774 PyObject *resultobj = 0;
9775 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9776 wxString *arg2 = 0 ;
9777 wxString const &arg3_defvalue = wxPyEmptyString ;
9778 wxString *arg3 = (wxString *) &arg3_defvalue ;
9779 bool result;
9780 void *argp1 = 0 ;
9781 int res1 = 0 ;
9782 bool temp2 = false ;
9783 bool temp3 = false ;
9784 PyObject * obj0 = 0 ;
9785 PyObject * obj1 = 0 ;
9786 PyObject * obj2 = 0 ;
9787 char * kwnames[] = {
9788 (char *) "self",(char *) "name",(char *) "path", NULL
9789 };
9790
9791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9793 if (!SWIG_IsOK(res1)) {
9794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_Create" "', expected argument " "1"" of type '" "wxSingleInstanceChecker *""'");
9795 }
9796 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9797 {
9798 arg2 = wxString_in_helper(obj1);
9799 if (arg2 == NULL) SWIG_fail;
9800 temp2 = true;
9801 }
9802 if (obj2) {
9803 {
9804 arg3 = wxString_in_helper(obj2);
9805 if (arg3 == NULL) SWIG_fail;
9806 temp3 = true;
9807 }
9808 }
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
9812 wxPyEndAllowThreads(__tstate);
9813 if (PyErr_Occurred()) SWIG_fail;
9814 }
9815 {
9816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9817 }
9818 {
9819 if (temp2)
9820 delete arg2;
9821 }
9822 {
9823 if (temp3)
9824 delete arg3;
9825 }
9826 return resultobj;
9827 fail:
9828 {
9829 if (temp2)
9830 delete arg2;
9831 }
9832 {
9833 if (temp3)
9834 delete arg3;
9835 }
9836 return NULL;
9837 }
9838
9839
9840 SWIGINTERN PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9841 PyObject *resultobj = 0;
9842 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
9843 bool result;
9844 void *argp1 = 0 ;
9845 int res1 = 0 ;
9846 PyObject *swig_obj[1] ;
9847
9848 if (!args) SWIG_fail;
9849 swig_obj[0] = args;
9850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSingleInstanceChecker, 0 | 0 );
9851 if (!SWIG_IsOK(res1)) {
9852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SingleInstanceChecker_IsAnotherRunning" "', expected argument " "1"" of type '" "wxSingleInstanceChecker const *""'");
9853 }
9854 arg1 = reinterpret_cast< wxSingleInstanceChecker * >(argp1);
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
9858 wxPyEndAllowThreads(__tstate);
9859 if (PyErr_Occurred()) SWIG_fail;
9860 }
9861 {
9862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9863 }
9864 return resultobj;
9865 fail:
9866 return NULL;
9867 }
9868
9869
9870 SWIGINTERN PyObject *SingleInstanceChecker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9871 PyObject *obj;
9872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9873 SWIG_TypeNewClientData(SWIGTYPE_p_wxSingleInstanceChecker, SWIG_NewClientData(obj));
9874 return SWIG_Py_Void();
9875 }
9876
9877 SWIGINTERN PyObject *SingleInstanceChecker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9878 return SWIG_Python_InitShadowInstance(args);
9879 }
9880
9881 SWIGINTERN PyObject *_wrap_DrawWindowOnDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj = 0;
9883 wxWindow *arg1 = (wxWindow *) 0 ;
9884 wxDC *arg2 = 0 ;
9885 bool result;
9886 void *argp1 = 0 ;
9887 int res1 = 0 ;
9888 void *argp2 = 0 ;
9889 int res2 = 0 ;
9890 PyObject * obj0 = 0 ;
9891 PyObject * obj1 = 0 ;
9892 char * kwnames[] = {
9893 (char *) "window",(char *) "dc", NULL
9894 };
9895
9896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) SWIG_fail;
9897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
9898 if (!SWIG_IsOK(res1)) {
9899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DrawWindowOnDC" "', expected argument " "1"" of type '" "wxWindow *""'");
9900 }
9901 arg1 = reinterpret_cast< wxWindow * >(argp1);
9902 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
9903 if (!SWIG_IsOK(res2)) {
9904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9905 }
9906 if (!argp2) {
9907 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DrawWindowOnDC" "', expected argument " "2"" of type '" "wxDC const &""'");
9908 }
9909 arg2 = reinterpret_cast< wxDC * >(argp2);
9910 {
9911 PyThreadState* __tstate = wxPyBeginAllowThreads();
9912 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
9913 wxPyEndAllowThreads(__tstate);
9914 if (PyErr_Occurred()) SWIG_fail;
9915 }
9916 {
9917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9918 }
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 SWIGINTERN PyObject *_wrap_delete_TipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9926 PyObject *resultobj = 0;
9927 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9928 void *argp1 = 0 ;
9929 int res1 = 0 ;
9930 PyObject *swig_obj[1] ;
9931
9932 if (!args) SWIG_fail;
9933 swig_obj[0] = args;
9934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, SWIG_POINTER_DISOWN | 0 );
9935 if (!SWIG_IsOK(res1)) {
9936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TipProvider" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9937 }
9938 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9939 {
9940 PyThreadState* __tstate = wxPyBeginAllowThreads();
9941 delete arg1;
9942
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 resultobj = SWIG_Py_Void();
9947 return resultobj;
9948 fail:
9949 return NULL;
9950 }
9951
9952
9953 SWIGINTERN PyObject *_wrap_TipProvider_GetTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9954 PyObject *resultobj = 0;
9955 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9956 wxString result;
9957 void *argp1 = 0 ;
9958 int res1 = 0 ;
9959 PyObject *swig_obj[1] ;
9960
9961 if (!args) SWIG_fail;
9962 swig_obj[0] = args;
9963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9964 if (!SWIG_IsOK(res1)) {
9965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
9966 }
9967 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
9968 {
9969 PyThreadState* __tstate = wxPyBeginAllowThreads();
9970 result = (arg1)->GetTip();
9971 wxPyEndAllowThreads(__tstate);
9972 if (PyErr_Occurred()) SWIG_fail;
9973 }
9974 {
9975 #if wxUSE_UNICODE
9976 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9977 #else
9978 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9979 #endif
9980 }
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 SWIGINTERN PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9988 PyObject *resultobj = 0;
9989 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
9990 size_t result;
9991 void *argp1 = 0 ;
9992 int res1 = 0 ;
9993 PyObject *swig_obj[1] ;
9994
9995 if (!args) SWIG_fail;
9996 swig_obj[0] = args;
9997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
9998 if (!SWIG_IsOK(res1)) {
9999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_GetCurrentTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10000 }
10001 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = (size_t)(arg1)->GetCurrentTip();
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
10009 return resultobj;
10010 fail:
10011 return NULL;
10012 }
10013
10014
10015 SWIGINTERN PyObject *_wrap_TipProvider_PreprocessTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10016 PyObject *resultobj = 0;
10017 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
10018 wxString *arg2 = 0 ;
10019 wxString result;
10020 void *argp1 = 0 ;
10021 int res1 = 0 ;
10022 bool temp2 = false ;
10023 PyObject * obj0 = 0 ;
10024 PyObject * obj1 = 0 ;
10025 char * kwnames[] = {
10026 (char *) "self",(char *) "tip", NULL
10027 };
10028
10029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) SWIG_fail;
10030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10031 if (!SWIG_IsOK(res1)) {
10032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TipProvider_PreprocessTip" "', expected argument " "1"" of type '" "wxTipProvider *""'");
10033 }
10034 arg1 = reinterpret_cast< wxTipProvider * >(argp1);
10035 {
10036 arg2 = wxString_in_helper(obj1);
10037 if (arg2 == NULL) SWIG_fail;
10038 temp2 = true;
10039 }
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 result = (arg1)->PreprocessTip((wxString const &)*arg2);
10043 wxPyEndAllowThreads(__tstate);
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 {
10047 #if wxUSE_UNICODE
10048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10049 #else
10050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10051 #endif
10052 }
10053 {
10054 if (temp2)
10055 delete arg2;
10056 }
10057 return resultobj;
10058 fail:
10059 {
10060 if (temp2)
10061 delete arg2;
10062 }
10063 return NULL;
10064 }
10065
10066
10067 SWIGINTERN PyObject *TipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10068 PyObject *obj;
10069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10070 SWIG_TypeNewClientData(SWIGTYPE_p_wxTipProvider, SWIG_NewClientData(obj));
10071 return SWIG_Py_Void();
10072 }
10073
10074 SWIGINTERN PyObject *_wrap_new_PyTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10075 PyObject *resultobj = 0;
10076 size_t arg1 ;
10077 wxPyTipProvider *result = 0 ;
10078 size_t val1 ;
10079 int ecode1 = 0 ;
10080 PyObject * obj0 = 0 ;
10081 char * kwnames[] = {
10082 (char *) "currentTip", NULL
10083 };
10084
10085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) SWIG_fail;
10086 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
10087 if (!SWIG_IsOK(ecode1)) {
10088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyTipProvider" "', expected argument " "1"" of type '" "size_t""'");
10089 }
10090 arg1 = static_cast< size_t >(val1);
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
10094 wxPyEndAllowThreads(__tstate);
10095 if (PyErr_Occurred()) SWIG_fail;
10096 }
10097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_NEW | 0 );
10098 return resultobj;
10099 fail:
10100 return NULL;
10101 }
10102
10103
10104 SWIGINTERN PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10105 PyObject *resultobj = 0;
10106 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
10107 PyObject *arg2 = (PyObject *) 0 ;
10108 PyObject *arg3 = (PyObject *) 0 ;
10109 void *argp1 = 0 ;
10110 int res1 = 0 ;
10111 PyObject * obj0 = 0 ;
10112 PyObject * obj1 = 0 ;
10113 PyObject * obj2 = 0 ;
10114 char * kwnames[] = {
10115 (char *) "self",(char *) "self",(char *) "_class", NULL
10116 };
10117
10118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTipProvider, 0 | 0 );
10120 if (!SWIG_IsOK(res1)) {
10121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTipProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTipProvider *""'");
10122 }
10123 arg1 = reinterpret_cast< wxPyTipProvider * >(argp1);
10124 arg2 = obj1;
10125 arg3 = obj2;
10126 {
10127 PyThreadState* __tstate = wxPyBeginAllowThreads();
10128 (arg1)->_setCallbackInfo(arg2,arg3);
10129 wxPyEndAllowThreads(__tstate);
10130 if (PyErr_Occurred()) SWIG_fail;
10131 }
10132 resultobj = SWIG_Py_Void();
10133 return resultobj;
10134 fail:
10135 return NULL;
10136 }
10137
10138
10139 SWIGINTERN PyObject *PyTipProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10140 PyObject *obj;
10141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10142 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTipProvider, SWIG_NewClientData(obj));
10143 return SWIG_Py_Void();
10144 }
10145
10146 SWIGINTERN PyObject *PyTipProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10147 return SWIG_Python_InitShadowInstance(args);
10148 }
10149
10150 SWIGINTERN PyObject *_wrap_ShowTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj = 0;
10152 wxWindow *arg1 = (wxWindow *) 0 ;
10153 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
10154 bool arg3 = (bool) true ;
10155 bool result;
10156 void *argp1 = 0 ;
10157 int res1 = 0 ;
10158 void *argp2 = 0 ;
10159 int res2 = 0 ;
10160 bool val3 ;
10161 int ecode3 = 0 ;
10162 PyObject * obj0 = 0 ;
10163 PyObject * obj1 = 0 ;
10164 PyObject * obj2 = 0 ;
10165 char * kwnames[] = {
10166 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
10167 };
10168
10169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
10171 if (!SWIG_IsOK(res1)) {
10172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowTip" "', expected argument " "1"" of type '" "wxWindow *""'");
10173 }
10174 arg1 = reinterpret_cast< wxWindow * >(argp1);
10175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTipProvider, 0 | 0 );
10176 if (!SWIG_IsOK(res2)) {
10177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShowTip" "', expected argument " "2"" of type '" "wxTipProvider *""'");
10178 }
10179 arg2 = reinterpret_cast< wxTipProvider * >(argp2);
10180 if (obj2) {
10181 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10182 if (!SWIG_IsOK(ecode3)) {
10183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ShowTip" "', expected argument " "3"" of type '" "bool""'");
10184 }
10185 arg3 = static_cast< bool >(val3);
10186 }
10187 {
10188 if (!wxPyCheckForApp()) SWIG_fail;
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (bool)wxShowTip(arg1,arg2,arg3);
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 {
10195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10196 }
10197 return resultobj;
10198 fail:
10199 return NULL;
10200 }
10201
10202
10203 SWIGINTERN PyObject *_wrap_CreateFileTipProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10204 PyObject *resultobj = 0;
10205 wxString *arg1 = 0 ;
10206 size_t arg2 ;
10207 wxTipProvider *result = 0 ;
10208 bool temp1 = false ;
10209 size_t val2 ;
10210 int ecode2 = 0 ;
10211 PyObject * obj0 = 0 ;
10212 PyObject * obj1 = 0 ;
10213 char * kwnames[] = {
10214 (char *) "filename",(char *) "currentTip", NULL
10215 };
10216
10217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) SWIG_fail;
10218 {
10219 arg1 = wxString_in_helper(obj0);
10220 if (arg1 == NULL) SWIG_fail;
10221 temp1 = true;
10222 }
10223 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
10224 if (!SWIG_IsOK(ecode2)) {
10225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateFileTipProvider" "', expected argument " "2"" of type '" "size_t""'");
10226 }
10227 arg2 = static_cast< size_t >(val2);
10228 {
10229 if (!wxPyCheckForApp()) SWIG_fail;
10230 PyThreadState* __tstate = wxPyBeginAllowThreads();
10231 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
10232 wxPyEndAllowThreads(__tstate);
10233 if (PyErr_Occurred()) SWIG_fail;
10234 }
10235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTipProvider, SWIG_POINTER_OWN | 0 );
10236 {
10237 if (temp1)
10238 delete arg1;
10239 }
10240 return resultobj;
10241 fail:
10242 {
10243 if (temp1)
10244 delete arg1;
10245 }
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_new_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = 0;
10252 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10253 int arg2 = (int) wxID_ANY ;
10254 wxPyTimer *result = 0 ;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 int val2 ;
10258 int ecode2 = 0 ;
10259 PyObject * obj0 = 0 ;
10260 PyObject * obj1 = 0 ;
10261 char * kwnames[] = {
10262 (char *) "owner",(char *) "id", NULL
10263 };
10264
10265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) SWIG_fail;
10266 if (obj0) {
10267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10268 if (!SWIG_IsOK(res1)) {
10269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Timer" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
10270 }
10271 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
10272 }
10273 if (obj1) {
10274 ecode2 = SWIG_AsVal_int(obj1, &val2);
10275 if (!SWIG_IsOK(ecode2)) {
10276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Timer" "', expected argument " "2"" of type '" "int""'");
10277 }
10278 arg2 = static_cast< int >(val2);
10279 }
10280 {
10281 if (!wxPyCheckForApp()) SWIG_fail;
10282 PyThreadState* __tstate = wxPyBeginAllowThreads();
10283 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
10284 wxPyEndAllowThreads(__tstate);
10285 if (PyErr_Occurred()) SWIG_fail;
10286 }
10287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTimer, SWIG_POINTER_NEW | 0 );
10288 return resultobj;
10289 fail:
10290 return NULL;
10291 }
10292
10293
10294 SWIGINTERN PyObject *_wrap_delete_Timer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10295 PyObject *resultobj = 0;
10296 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10297 void *argp1 = 0 ;
10298 int res1 = 0 ;
10299 PyObject *swig_obj[1] ;
10300
10301 if (!args) SWIG_fail;
10302 swig_obj[0] = args;
10303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, SWIG_POINTER_DISOWN | 0 );
10304 if (!SWIG_IsOK(res1)) {
10305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Timer" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10306 }
10307 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 delete arg1;
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 resultobj = SWIG_Py_Void();
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 SWIGINTERN PyObject *_wrap_Timer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10323 PyObject *resultobj = 0;
10324 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10325 PyObject *arg2 = (PyObject *) 0 ;
10326 PyObject *arg3 = (PyObject *) 0 ;
10327 int arg4 = (int) 1 ;
10328 void *argp1 = 0 ;
10329 int res1 = 0 ;
10330 int val4 ;
10331 int ecode4 = 0 ;
10332 PyObject * obj0 = 0 ;
10333 PyObject * obj1 = 0 ;
10334 PyObject * obj2 = 0 ;
10335 PyObject * obj3 = 0 ;
10336 char * kwnames[] = {
10337 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
10338 };
10339
10340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
10341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10342 if (!SWIG_IsOK(res1)) {
10343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10344 }
10345 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10346 arg2 = obj1;
10347 arg3 = obj2;
10348 if (obj3) {
10349 ecode4 = SWIG_AsVal_int(obj3, &val4);
10350 if (!SWIG_IsOK(ecode4)) {
10351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Timer__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
10352 }
10353 arg4 = static_cast< int >(val4);
10354 }
10355 {
10356 PyThreadState* __tstate = wxPyBeginAllowThreads();
10357 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
10358 wxPyEndAllowThreads(__tstate);
10359 if (PyErr_Occurred()) SWIG_fail;
10360 }
10361 resultobj = SWIG_Py_Void();
10362 return resultobj;
10363 fail:
10364 return NULL;
10365 }
10366
10367
10368 SWIGINTERN PyObject *_wrap_Timer_SetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10369 PyObject *resultobj = 0;
10370 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10371 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
10372 int arg3 = (int) wxID_ANY ;
10373 void *argp1 = 0 ;
10374 int res1 = 0 ;
10375 void *argp2 = 0 ;
10376 int res2 = 0 ;
10377 int val3 ;
10378 int ecode3 = 0 ;
10379 PyObject * obj0 = 0 ;
10380 PyObject * obj1 = 0 ;
10381 PyObject * obj2 = 0 ;
10382 char * kwnames[] = {
10383 (char *) "self",(char *) "owner",(char *) "id", NULL
10384 };
10385
10386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10388 if (!SWIG_IsOK(res1)) {
10389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_SetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10390 }
10391 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
10393 if (!SWIG_IsOK(res2)) {
10394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Timer_SetOwner" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
10395 }
10396 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
10397 if (obj2) {
10398 ecode3 = SWIG_AsVal_int(obj2, &val3);
10399 if (!SWIG_IsOK(ecode3)) {
10400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_SetOwner" "', expected argument " "3"" of type '" "int""'");
10401 }
10402 arg3 = static_cast< int >(val3);
10403 }
10404 {
10405 PyThreadState* __tstate = wxPyBeginAllowThreads();
10406 (arg1)->SetOwner(arg2,arg3);
10407 wxPyEndAllowThreads(__tstate);
10408 if (PyErr_Occurred()) SWIG_fail;
10409 }
10410 resultobj = SWIG_Py_Void();
10411 return resultobj;
10412 fail:
10413 return NULL;
10414 }
10415
10416
10417 SWIGINTERN PyObject *_wrap_Timer_GetOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10418 PyObject *resultobj = 0;
10419 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10420 wxEvtHandler *result = 0 ;
10421 void *argp1 = 0 ;
10422 int res1 = 0 ;
10423 PyObject *swig_obj[1] ;
10424
10425 if (!args) SWIG_fail;
10426 swig_obj[0] = args;
10427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10428 if (!SWIG_IsOK(res1)) {
10429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetOwner" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10430 }
10431 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10432 {
10433 PyThreadState* __tstate = wxPyBeginAllowThreads();
10434 result = (wxEvtHandler *)(arg1)->GetOwner();
10435 wxPyEndAllowThreads(__tstate);
10436 if (PyErr_Occurred()) SWIG_fail;
10437 }
10438 {
10439 resultobj = wxPyMake_wxObject(result, 0);
10440 }
10441 return resultobj;
10442 fail:
10443 return NULL;
10444 }
10445
10446
10447 SWIGINTERN PyObject *_wrap_Timer_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10448 PyObject *resultobj = 0;
10449 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10450 int arg2 = (int) -1 ;
10451 bool arg3 = (bool) false ;
10452 bool result;
10453 void *argp1 = 0 ;
10454 int res1 = 0 ;
10455 int val2 ;
10456 int ecode2 = 0 ;
10457 bool val3 ;
10458 int ecode3 = 0 ;
10459 PyObject * obj0 = 0 ;
10460 PyObject * obj1 = 0 ;
10461 PyObject * obj2 = 0 ;
10462 char * kwnames[] = {
10463 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
10464 };
10465
10466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10468 if (!SWIG_IsOK(res1)) {
10469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Start" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10470 }
10471 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10472 if (obj1) {
10473 ecode2 = SWIG_AsVal_int(obj1, &val2);
10474 if (!SWIG_IsOK(ecode2)) {
10475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timer_Start" "', expected argument " "2"" of type '" "int""'");
10476 }
10477 arg2 = static_cast< int >(val2);
10478 }
10479 if (obj2) {
10480 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10481 if (!SWIG_IsOK(ecode3)) {
10482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Timer_Start" "', expected argument " "3"" of type '" "bool""'");
10483 }
10484 arg3 = static_cast< bool >(val3);
10485 }
10486 {
10487 PyThreadState* __tstate = wxPyBeginAllowThreads();
10488 result = (bool)(arg1)->Start(arg2,arg3);
10489 wxPyEndAllowThreads(__tstate);
10490 if (PyErr_Occurred()) SWIG_fail;
10491 }
10492 {
10493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10494 }
10495 return resultobj;
10496 fail:
10497 return NULL;
10498 }
10499
10500
10501 SWIGINTERN PyObject *_wrap_Timer_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10502 PyObject *resultobj = 0;
10503 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10504 void *argp1 = 0 ;
10505 int res1 = 0 ;
10506 PyObject *swig_obj[1] ;
10507
10508 if (!args) SWIG_fail;
10509 swig_obj[0] = args;
10510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10511 if (!SWIG_IsOK(res1)) {
10512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Stop" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10513 }
10514 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10515 {
10516 PyThreadState* __tstate = wxPyBeginAllowThreads();
10517 (arg1)->Stop();
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 resultobj = SWIG_Py_Void();
10522 return resultobj;
10523 fail:
10524 return NULL;
10525 }
10526
10527
10528 SWIGINTERN PyObject *_wrap_Timer_Notify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10529 PyObject *resultobj = 0;
10530 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10531 void *argp1 = 0 ;
10532 int res1 = 0 ;
10533 PyObject *swig_obj[1] ;
10534
10535 if (!args) SWIG_fail;
10536 swig_obj[0] = args;
10537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10538 if (!SWIG_IsOK(res1)) {
10539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_Notify" "', expected argument " "1"" of type '" "wxPyTimer *""'");
10540 }
10541 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10542 {
10543 PyThreadState* __tstate = wxPyBeginAllowThreads();
10544 (arg1)->Notify();
10545 wxPyEndAllowThreads(__tstate);
10546 if (PyErr_Occurred()) SWIG_fail;
10547 }
10548 resultobj = SWIG_Py_Void();
10549 return resultobj;
10550 fail:
10551 return NULL;
10552 }
10553
10554
10555 SWIGINTERN PyObject *_wrap_Timer_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10556 PyObject *resultobj = 0;
10557 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10558 bool result;
10559 void *argp1 = 0 ;
10560 int res1 = 0 ;
10561 PyObject *swig_obj[1] ;
10562
10563 if (!args) SWIG_fail;
10564 swig_obj[0] = args;
10565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10566 if (!SWIG_IsOK(res1)) {
10567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsRunning" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10568 }
10569 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10570 {
10571 PyThreadState* __tstate = wxPyBeginAllowThreads();
10572 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
10573 wxPyEndAllowThreads(__tstate);
10574 if (PyErr_Occurred()) SWIG_fail;
10575 }
10576 {
10577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10578 }
10579 return resultobj;
10580 fail:
10581 return NULL;
10582 }
10583
10584
10585 SWIGINTERN PyObject *_wrap_Timer_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10586 PyObject *resultobj = 0;
10587 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10588 int result;
10589 void *argp1 = 0 ;
10590 int res1 = 0 ;
10591 PyObject *swig_obj[1] ;
10592
10593 if (!args) SWIG_fail;
10594 swig_obj[0] = args;
10595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10596 if (!SWIG_IsOK(res1)) {
10597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetInterval" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10598 }
10599 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10600 {
10601 PyThreadState* __tstate = wxPyBeginAllowThreads();
10602 result = (int)((wxPyTimer const *)arg1)->GetInterval();
10603 wxPyEndAllowThreads(__tstate);
10604 if (PyErr_Occurred()) SWIG_fail;
10605 }
10606 resultobj = SWIG_From_int(static_cast< int >(result));
10607 return resultobj;
10608 fail:
10609 return NULL;
10610 }
10611
10612
10613 SWIGINTERN PyObject *_wrap_Timer_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10614 PyObject *resultobj = 0;
10615 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10616 int result;
10617 void *argp1 = 0 ;
10618 int res1 = 0 ;
10619 PyObject *swig_obj[1] ;
10620
10621 if (!args) SWIG_fail;
10622 swig_obj[0] = args;
10623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10624 if (!SWIG_IsOK(res1)) {
10625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_GetId" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10626 }
10627 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10628 {
10629 PyThreadState* __tstate = wxPyBeginAllowThreads();
10630 result = (int)((wxPyTimer const *)arg1)->GetId();
10631 wxPyEndAllowThreads(__tstate);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 resultobj = SWIG_From_int(static_cast< int >(result));
10635 return resultobj;
10636 fail:
10637 return NULL;
10638 }
10639
10640
10641 SWIGINTERN PyObject *_wrap_Timer_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10642 PyObject *resultobj = 0;
10643 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
10644 bool result;
10645 void *argp1 = 0 ;
10646 int res1 = 0 ;
10647 PyObject *swig_obj[1] ;
10648
10649 if (!args) SWIG_fail;
10650 swig_obj[0] = args;
10651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTimer, 0 | 0 );
10652 if (!SWIG_IsOK(res1)) {
10653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timer_IsOneShot" "', expected argument " "1"" of type '" "wxPyTimer const *""'");
10654 }
10655 arg1 = reinterpret_cast< wxPyTimer * >(argp1);
10656 {
10657 PyThreadState* __tstate = wxPyBeginAllowThreads();
10658 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
10659 wxPyEndAllowThreads(__tstate);
10660 if (PyErr_Occurred()) SWIG_fail;
10661 }
10662 {
10663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10664 }
10665 return resultobj;
10666 fail:
10667 return NULL;
10668 }
10669
10670
10671 SWIGINTERN PyObject *Timer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10672 PyObject *obj;
10673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10674 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTimer, SWIG_NewClientData(obj));
10675 return SWIG_Py_Void();
10676 }
10677
10678 SWIGINTERN PyObject *Timer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10679 return SWIG_Python_InitShadowInstance(args);
10680 }
10681
10682 SWIGINTERN PyObject *_wrap_new_TimerEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10683 PyObject *resultobj = 0;
10684 int arg1 = (int) 0 ;
10685 int arg2 = (int) 0 ;
10686 wxTimerEvent *result = 0 ;
10687 int val1 ;
10688 int ecode1 = 0 ;
10689 int val2 ;
10690 int ecode2 = 0 ;
10691 PyObject * obj0 = 0 ;
10692 PyObject * obj1 = 0 ;
10693 char * kwnames[] = {
10694 (char *) "timerid",(char *) "interval", NULL
10695 };
10696
10697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) SWIG_fail;
10698 if (obj0) {
10699 ecode1 = SWIG_AsVal_int(obj0, &val1);
10700 if (!SWIG_IsOK(ecode1)) {
10701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimerEvent" "', expected argument " "1"" of type '" "int""'");
10702 }
10703 arg1 = static_cast< int >(val1);
10704 }
10705 if (obj1) {
10706 ecode2 = SWIG_AsVal_int(obj1, &val2);
10707 if (!SWIG_IsOK(ecode2)) {
10708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerEvent" "', expected argument " "2"" of type '" "int""'");
10709 }
10710 arg2 = static_cast< int >(val2);
10711 }
10712 {
10713 PyThreadState* __tstate = wxPyBeginAllowThreads();
10714 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
10715 wxPyEndAllowThreads(__tstate);
10716 if (PyErr_Occurred()) SWIG_fail;
10717 }
10718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_NEW | 0 );
10719 return resultobj;
10720 fail:
10721 return NULL;
10722 }
10723
10724
10725 SWIGINTERN PyObject *_wrap_TimerEvent_GetInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10726 PyObject *resultobj = 0;
10727 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
10728 int result;
10729 void *argp1 = 0 ;
10730 int res1 = 0 ;
10731 PyObject *swig_obj[1] ;
10732
10733 if (!args) SWIG_fail;
10734 swig_obj[0] = args;
10735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerEvent, 0 | 0 );
10736 if (!SWIG_IsOK(res1)) {
10737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerEvent_GetInterval" "', expected argument " "1"" of type '" "wxTimerEvent const *""'");
10738 }
10739 arg1 = reinterpret_cast< wxTimerEvent * >(argp1);
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 resultobj = SWIG_From_int(static_cast< int >(result));
10747 return resultobj;
10748 fail:
10749 return NULL;
10750 }
10751
10752
10753 SWIGINTERN PyObject *TimerEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10754 PyObject *obj;
10755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10756 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerEvent, SWIG_NewClientData(obj));
10757 return SWIG_Py_Void();
10758 }
10759
10760 SWIGINTERN PyObject *TimerEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10761 return SWIG_Python_InitShadowInstance(args);
10762 }
10763
10764 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10765 PyObject *resultobj = 0;
10766 wxTimer *arg1 = 0 ;
10767 wxTimerRunner *result = 0 ;
10768 void *argp1 = 0 ;
10769 int res1 = 0 ;
10770
10771 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
10772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10773 if (!SWIG_IsOK(res1)) {
10774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10775 }
10776 if (!argp1) {
10777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10778 }
10779 arg1 = reinterpret_cast< wxTimer * >(argp1);
10780 {
10781 if (!wxPyCheckForApp()) SWIG_fail;
10782 PyThreadState* __tstate = wxPyBeginAllowThreads();
10783 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
10784 wxPyEndAllowThreads(__tstate);
10785 if (PyErr_Occurred()) SWIG_fail;
10786 }
10787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10788 return resultobj;
10789 fail:
10790 return NULL;
10791 }
10792
10793
10794 SWIGINTERN PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10795 PyObject *resultobj = 0;
10796 wxTimer *arg1 = 0 ;
10797 int arg2 ;
10798 bool arg3 = (bool) false ;
10799 wxTimerRunner *result = 0 ;
10800 void *argp1 = 0 ;
10801 int res1 = 0 ;
10802 int val2 ;
10803 int ecode2 = 0 ;
10804 bool val3 ;
10805 int ecode3 = 0 ;
10806
10807 if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
10808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxTimer, 0 );
10809 if (!SWIG_IsOK(res1)) {
10810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10811 }
10812 if (!argp1) {
10813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TimerRunner" "', expected argument " "1"" of type '" "wxTimer &""'");
10814 }
10815 arg1 = reinterpret_cast< wxTimer * >(argp1);
10816 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10817 if (!SWIG_IsOK(ecode2)) {
10818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimerRunner" "', expected argument " "2"" of type '" "int""'");
10819 }
10820 arg2 = static_cast< int >(val2);
10821 if (swig_obj[2]) {
10822 ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
10823 if (!SWIG_IsOK(ecode3)) {
10824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimerRunner" "', expected argument " "3"" of type '" "bool""'");
10825 }
10826 arg3 = static_cast< bool >(val3);
10827 }
10828 {
10829 if (!wxPyCheckForApp()) SWIG_fail;
10830 PyThreadState* __tstate = wxPyBeginAllowThreads();
10831 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
10832 wxPyEndAllowThreads(__tstate);
10833 if (PyErr_Occurred()) SWIG_fail;
10834 }
10835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_NEW | 0 );
10836 return resultobj;
10837 fail:
10838 return NULL;
10839 }
10840
10841
10842 SWIGINTERN PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
10843 int argc;
10844 PyObject *argv[4];
10845
10846 if (!(argc = SWIG_Python_UnpackTuple(args,"new_TimerRunner",0,3,argv))) SWIG_fail;
10847 --argc;
10848 if (argc == 1) {
10849 return _wrap_new_TimerRunner__SWIG_0(self, argc, argv);
10850 }
10851 if ((argc >= 2) && (argc <= 3)) {
10852 return _wrap_new_TimerRunner__SWIG_1(self, argc, argv);
10853 }
10854
10855 fail:
10856 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
10857 return NULL;
10858 }
10859
10860
10861 SWIGINTERN PyObject *_wrap_delete_TimerRunner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10862 PyObject *resultobj = 0;
10863 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10864 void *argp1 = 0 ;
10865 int res1 = 0 ;
10866 PyObject *swig_obj[1] ;
10867
10868 if (!args) SWIG_fail;
10869 swig_obj[0] = args;
10870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_DISOWN | 0 );
10871 if (!SWIG_IsOK(res1)) {
10872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimerRunner" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10873 }
10874 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10875 {
10876 PyThreadState* __tstate = wxPyBeginAllowThreads();
10877 delete arg1;
10878
10879 wxPyEndAllowThreads(__tstate);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 resultobj = SWIG_Py_Void();
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_TimerRunner_Start(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj = 0;
10891 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
10892 int arg2 ;
10893 bool arg3 = (bool) false ;
10894 void *argp1 = 0 ;
10895 int res1 = 0 ;
10896 int val2 ;
10897 int ecode2 = 0 ;
10898 bool val3 ;
10899 int ecode3 = 0 ;
10900 PyObject * obj0 = 0 ;
10901 PyObject * obj1 = 0 ;
10902 PyObject * obj2 = 0 ;
10903 char * kwnames[] = {
10904 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
10905 };
10906
10907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimerRunner, 0 | 0 );
10909 if (!SWIG_IsOK(res1)) {
10910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimerRunner_Start" "', expected argument " "1"" of type '" "wxTimerRunner *""'");
10911 }
10912 arg1 = reinterpret_cast< wxTimerRunner * >(argp1);
10913 ecode2 = SWIG_AsVal_int(obj1, &val2);
10914 if (!SWIG_IsOK(ecode2)) {
10915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimerRunner_Start" "', expected argument " "2"" of type '" "int""'");
10916 }
10917 arg2 = static_cast< int >(val2);
10918 if (obj2) {
10919 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10920 if (!SWIG_IsOK(ecode3)) {
10921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimerRunner_Start" "', expected argument " "3"" of type '" "bool""'");
10922 }
10923 arg3 = static_cast< bool >(val3);
10924 }
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->Start(arg2,arg3);
10928 wxPyEndAllowThreads(__tstate);
10929 if (PyErr_Occurred()) SWIG_fail;
10930 }
10931 resultobj = SWIG_Py_Void();
10932 return resultobj;
10933 fail:
10934 return NULL;
10935 }
10936
10937
10938 SWIGINTERN PyObject *TimerRunner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10939 PyObject *obj;
10940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10941 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimerRunner, SWIG_NewClientData(obj));
10942 return SWIG_Py_Void();
10943 }
10944
10945 SWIGINTERN PyObject *TimerRunner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10946 return SWIG_Python_InitShadowInstance(args);
10947 }
10948
10949 SWIGINTERN PyObject *_wrap_new_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10950 PyObject *resultobj = 0;
10951 wxLog *result = 0 ;
10952
10953 if (!SWIG_Python_UnpackTuple(args,"new_Log",0,0,0)) SWIG_fail;
10954 {
10955 PyThreadState* __tstate = wxPyBeginAllowThreads();
10956 result = (wxLog *)new wxLog();
10957 wxPyEndAllowThreads(__tstate);
10958 if (PyErr_Occurred()) SWIG_fail;
10959 }
10960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_NEW | 0 );
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 SWIGINTERN PyObject *_wrap_delete_Log(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10968 PyObject *resultobj = 0;
10969 wxLog *arg1 = (wxLog *) 0 ;
10970 void *argp1 = 0 ;
10971 int res1 = 0 ;
10972 PyObject *swig_obj[1] ;
10973
10974 if (!args) SWIG_fail;
10975 swig_obj[0] = args;
10976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
10977 if (!SWIG_IsOK(res1)) {
10978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Log" "', expected argument " "1"" of type '" "wxLog *""'");
10979 }
10980 arg1 = reinterpret_cast< wxLog * >(argp1);
10981 {
10982 PyThreadState* __tstate = wxPyBeginAllowThreads();
10983 delete arg1;
10984
10985 wxPyEndAllowThreads(__tstate);
10986 if (PyErr_Occurred()) SWIG_fail;
10987 }
10988 resultobj = SWIG_Py_Void();
10989 return resultobj;
10990 fail:
10991 return NULL;
10992 }
10993
10994
10995 SWIGINTERN PyObject *_wrap_Log_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10996 PyObject *resultobj = 0;
10997 bool result;
10998
10999 if (!SWIG_Python_UnpackTuple(args,"Log_IsEnabled",0,0,0)) SWIG_fail;
11000 {
11001 PyThreadState* __tstate = wxPyBeginAllowThreads();
11002 result = (bool)wxLog::IsEnabled();
11003 wxPyEndAllowThreads(__tstate);
11004 if (PyErr_Occurred()) SWIG_fail;
11005 }
11006 {
11007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11008 }
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 SWIGINTERN PyObject *_wrap_Log_EnableLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj = 0;
11017 bool arg1 = (bool) true ;
11018 bool result;
11019 bool val1 ;
11020 int ecode1 = 0 ;
11021 PyObject * obj0 = 0 ;
11022 char * kwnames[] = {
11023 (char *) "doIt", NULL
11024 };
11025
11026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) SWIG_fail;
11027 if (obj0) {
11028 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11029 if (!SWIG_IsOK(ecode1)) {
11030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_EnableLogging" "', expected argument " "1"" of type '" "bool""'");
11031 }
11032 arg1 = static_cast< bool >(val1);
11033 }
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 result = (bool)wxLog::EnableLogging(arg1);
11037 wxPyEndAllowThreads(__tstate);
11038 if (PyErr_Occurred()) SWIG_fail;
11039 }
11040 {
11041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11042 }
11043 return resultobj;
11044 fail:
11045 return NULL;
11046 }
11047
11048
11049 SWIGINTERN PyObject *_wrap_Log_OnLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11050 PyObject *resultobj = 0;
11051 wxLogLevel arg1 ;
11052 wxChar *arg2 = (wxChar *) 0 ;
11053 time_t arg3 ;
11054 unsigned long val1 ;
11055 int ecode1 = 0 ;
11056 void *argp2 = 0 ;
11057 int res2 = 0 ;
11058 unsigned int val3 ;
11059 int ecode3 = 0 ;
11060 PyObject * obj0 = 0 ;
11061 PyObject * obj1 = 0 ;
11062 PyObject * obj2 = 0 ;
11063 char * kwnames[] = {
11064 (char *) "level",(char *) "szString",(char *) "t", NULL
11065 };
11066
11067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11068 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11069 if (!SWIG_IsOK(ecode1)) {
11070 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_OnLog" "', expected argument " "1"" of type '" "wxLogLevel""'");
11071 }
11072 arg1 = static_cast< wxLogLevel >(val1);
11073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxChar, 0 | 0 );
11074 if (!SWIG_IsOK(res2)) {
11075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Log_OnLog" "', expected argument " "2"" of type '" "wxChar const *""'");
11076 }
11077 arg2 = reinterpret_cast< wxChar * >(argp2);
11078 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
11079 if (!SWIG_IsOK(ecode3)) {
11080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Log_OnLog" "', expected argument " "3"" of type '" "time_t""'");
11081 }
11082 arg3 = static_cast< time_t >(val3);
11083 {
11084 PyThreadState* __tstate = wxPyBeginAllowThreads();
11085 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
11086 wxPyEndAllowThreads(__tstate);
11087 if (PyErr_Occurred()) SWIG_fail;
11088 }
11089 resultobj = SWIG_Py_Void();
11090 return resultobj;
11091 fail:
11092 return NULL;
11093 }
11094
11095
11096 SWIGINTERN PyObject *_wrap_Log_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11097 PyObject *resultobj = 0;
11098 wxLog *arg1 = (wxLog *) 0 ;
11099 void *argp1 = 0 ;
11100 int res1 = 0 ;
11101 PyObject *swig_obj[1] ;
11102
11103 if (!args) SWIG_fail;
11104 swig_obj[0] = args;
11105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11106 if (!SWIG_IsOK(res1)) {
11107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Flush" "', expected argument " "1"" of type '" "wxLog *""'");
11108 }
11109 arg1 = reinterpret_cast< wxLog * >(argp1);
11110 {
11111 PyThreadState* __tstate = wxPyBeginAllowThreads();
11112 (arg1)->Flush();
11113 wxPyEndAllowThreads(__tstate);
11114 if (PyErr_Occurred()) SWIG_fail;
11115 }
11116 resultobj = SWIG_Py_Void();
11117 return resultobj;
11118 fail:
11119 return NULL;
11120 }
11121
11122
11123 SWIGINTERN PyObject *_wrap_Log_FlushActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11124 PyObject *resultobj = 0;
11125
11126 if (!SWIG_Python_UnpackTuple(args,"Log_FlushActive",0,0,0)) SWIG_fail;
11127 {
11128 PyThreadState* __tstate = wxPyBeginAllowThreads();
11129 wxLog::FlushActive();
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 resultobj = SWIG_Py_Void();
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 SWIGINTERN PyObject *_wrap_Log_GetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11141 PyObject *resultobj = 0;
11142 wxLog *result = 0 ;
11143
11144 if (!SWIG_Python_UnpackTuple(args,"Log_GetActiveTarget",0,0,0)) SWIG_fail;
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (wxLog *)wxLog::GetActiveTarget();
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11152 return resultobj;
11153 fail:
11154 return NULL;
11155 }
11156
11157
11158 SWIGINTERN PyObject *_wrap_Log_SetActiveTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11159 PyObject *resultobj = 0;
11160 wxLog *arg1 = (wxLog *) 0 ;
11161 wxLog *result = 0 ;
11162 int res1 = 0 ;
11163 PyObject * obj0 = 0 ;
11164 char * kwnames[] = {
11165 (char *) "pLogger", NULL
11166 };
11167
11168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) SWIG_fail;
11169 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxLog, SWIG_POINTER_DISOWN | 0 );
11170 if (!SWIG_IsOK(res1)) {
11171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetActiveTarget" "', expected argument " "1"" of type '" "wxLog *""'");
11172 }
11173 {
11174 PyThreadState* __tstate = wxPyBeginAllowThreads();
11175 result = (wxLog *)wxLog::SetActiveTarget(arg1);
11176 wxPyEndAllowThreads(__tstate);
11177 if (PyErr_Occurred()) SWIG_fail;
11178 }
11179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, SWIG_POINTER_OWN | 0 );
11180 return resultobj;
11181 fail:
11182 return NULL;
11183 }
11184
11185
11186 SWIGINTERN PyObject *_wrap_Log_Suspend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11187 PyObject *resultobj = 0;
11188
11189 if (!SWIG_Python_UnpackTuple(args,"Log_Suspend",0,0,0)) SWIG_fail;
11190 {
11191 PyThreadState* __tstate = wxPyBeginAllowThreads();
11192 wxLog::Suspend();
11193 wxPyEndAllowThreads(__tstate);
11194 if (PyErr_Occurred()) SWIG_fail;
11195 }
11196 resultobj = SWIG_Py_Void();
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 SWIGINTERN PyObject *_wrap_Log_Resume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11204 PyObject *resultobj = 0;
11205
11206 if (!SWIG_Python_UnpackTuple(args,"Log_Resume",0,0,0)) SWIG_fail;
11207 {
11208 PyThreadState* __tstate = wxPyBeginAllowThreads();
11209 wxLog::Resume();
11210 wxPyEndAllowThreads(__tstate);
11211 if (PyErr_Occurred()) SWIG_fail;
11212 }
11213 resultobj = SWIG_Py_Void();
11214 return resultobj;
11215 fail:
11216 return NULL;
11217 }
11218
11219
11220 SWIGINTERN PyObject *_wrap_Log_SetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11221 PyObject *resultobj = 0;
11222 bool arg1 = (bool) true ;
11223 bool val1 ;
11224 int ecode1 = 0 ;
11225 PyObject * obj0 = 0 ;
11226 char * kwnames[] = {
11227 (char *) "bVerbose", NULL
11228 };
11229
11230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) SWIG_fail;
11231 if (obj0) {
11232 ecode1 = SWIG_AsVal_bool(obj0, &val1);
11233 if (!SWIG_IsOK(ecode1)) {
11234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetVerbose" "', expected argument " "1"" of type '" "bool""'");
11235 }
11236 arg1 = static_cast< bool >(val1);
11237 }
11238 {
11239 PyThreadState* __tstate = wxPyBeginAllowThreads();
11240 wxLog::SetVerbose(arg1);
11241 wxPyEndAllowThreads(__tstate);
11242 if (PyErr_Occurred()) SWIG_fail;
11243 }
11244 resultobj = SWIG_Py_Void();
11245 return resultobj;
11246 fail:
11247 return NULL;
11248 }
11249
11250
11251 SWIGINTERN PyObject *_wrap_Log_SetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11252 PyObject *resultobj = 0;
11253 wxLogLevel arg1 ;
11254 unsigned long val1 ;
11255 int ecode1 = 0 ;
11256 PyObject * obj0 = 0 ;
11257 char * kwnames[] = {
11258 (char *) "logLevel", NULL
11259 };
11260
11261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) SWIG_fail;
11262 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11263 if (!SWIG_IsOK(ecode1)) {
11264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetLogLevel" "', expected argument " "1"" of type '" "wxLogLevel""'");
11265 }
11266 arg1 = static_cast< wxLogLevel >(val1);
11267 {
11268 PyThreadState* __tstate = wxPyBeginAllowThreads();
11269 wxLog::SetLogLevel(arg1);
11270 wxPyEndAllowThreads(__tstate);
11271 if (PyErr_Occurred()) SWIG_fail;
11272 }
11273 resultobj = SWIG_Py_Void();
11274 return resultobj;
11275 fail:
11276 return NULL;
11277 }
11278
11279
11280 SWIGINTERN PyObject *_wrap_Log_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11281 PyObject *resultobj = 0;
11282
11283 if (!SWIG_Python_UnpackTuple(args,"Log_DontCreateOnDemand",0,0,0)) SWIG_fail;
11284 {
11285 PyThreadState* __tstate = wxPyBeginAllowThreads();
11286 wxLog::DontCreateOnDemand();
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 resultobj = SWIG_Py_Void();
11291 return resultobj;
11292 fail:
11293 return NULL;
11294 }
11295
11296
11297 SWIGINTERN PyObject *_wrap_Log_SetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11298 PyObject *resultobj = 0;
11299 wxTraceMask arg1 ;
11300 unsigned long val1 ;
11301 int ecode1 = 0 ;
11302 PyObject * obj0 = 0 ;
11303 char * kwnames[] = {
11304 (char *) "ulMask", NULL
11305 };
11306
11307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) SWIG_fail;
11308 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
11309 if (!SWIG_IsOK(ecode1)) {
11310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Log_SetTraceMask" "', expected argument " "1"" of type '" "wxTraceMask""'");
11311 }
11312 arg1 = static_cast< wxTraceMask >(val1);
11313 {
11314 PyThreadState* __tstate = wxPyBeginAllowThreads();
11315 wxLog::SetTraceMask(arg1);
11316 wxPyEndAllowThreads(__tstate);
11317 if (PyErr_Occurred()) SWIG_fail;
11318 }
11319 resultobj = SWIG_Py_Void();
11320 return resultobj;
11321 fail:
11322 return NULL;
11323 }
11324
11325
11326 SWIGINTERN PyObject *_wrap_Log_AddTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11327 PyObject *resultobj = 0;
11328 wxString *arg1 = 0 ;
11329 bool temp1 = false ;
11330 PyObject * obj0 = 0 ;
11331 char * kwnames[] = {
11332 (char *) "str", NULL
11333 };
11334
11335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) SWIG_fail;
11336 {
11337 arg1 = wxString_in_helper(obj0);
11338 if (arg1 == NULL) SWIG_fail;
11339 temp1 = true;
11340 }
11341 {
11342 PyThreadState* __tstate = wxPyBeginAllowThreads();
11343 wxLog::AddTraceMask((wxString const &)*arg1);
11344 wxPyEndAllowThreads(__tstate);
11345 if (PyErr_Occurred()) SWIG_fail;
11346 }
11347 resultobj = SWIG_Py_Void();
11348 {
11349 if (temp1)
11350 delete arg1;
11351 }
11352 return resultobj;
11353 fail:
11354 {
11355 if (temp1)
11356 delete arg1;
11357 }
11358 return NULL;
11359 }
11360
11361
11362 SWIGINTERN PyObject *_wrap_Log_RemoveTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11363 PyObject *resultobj = 0;
11364 wxString *arg1 = 0 ;
11365 bool temp1 = false ;
11366 PyObject * obj0 = 0 ;
11367 char * kwnames[] = {
11368 (char *) "str", NULL
11369 };
11370
11371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) SWIG_fail;
11372 {
11373 arg1 = wxString_in_helper(obj0);
11374 if (arg1 == NULL) SWIG_fail;
11375 temp1 = true;
11376 }
11377 {
11378 PyThreadState* __tstate = wxPyBeginAllowThreads();
11379 wxLog::RemoveTraceMask((wxString const &)*arg1);
11380 wxPyEndAllowThreads(__tstate);
11381 if (PyErr_Occurred()) SWIG_fail;
11382 }
11383 resultobj = SWIG_Py_Void();
11384 {
11385 if (temp1)
11386 delete arg1;
11387 }
11388 return resultobj;
11389 fail:
11390 {
11391 if (temp1)
11392 delete arg1;
11393 }
11394 return NULL;
11395 }
11396
11397
11398 SWIGINTERN PyObject *_wrap_Log_ClearTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11399 PyObject *resultobj = 0;
11400
11401 if (!SWIG_Python_UnpackTuple(args,"Log_ClearTraceMasks",0,0,0)) SWIG_fail;
11402 {
11403 PyThreadState* __tstate = wxPyBeginAllowThreads();
11404 wxLog::ClearTraceMasks();
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 resultobj = SWIG_Py_Void();
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 SWIGINTERN PyObject *_wrap_Log_GetTraceMasks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11416 PyObject *resultobj = 0;
11417 wxArrayString *result = 0 ;
11418
11419 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMasks",0,0,0)) SWIG_fail;
11420 {
11421 PyThreadState* __tstate = wxPyBeginAllowThreads();
11422 {
11423 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
11424 result = (wxArrayString *) &_result_ref;
11425 }
11426 wxPyEndAllowThreads(__tstate);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 {
11430 resultobj = wxArrayString2PyList_helper(*result);
11431 }
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 SWIGINTERN PyObject *_wrap_Log_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11439 PyObject *resultobj = 0;
11440 wxChar *arg1 = (wxChar *) 0 ;
11441 void *argp1 = 0 ;
11442 int res1 = 0 ;
11443 PyObject * obj0 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "ts", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) SWIG_fail;
11449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11450 if (!SWIG_IsOK(res1)) {
11451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_SetTimestamp" "', expected argument " "1"" of type '" "wxChar const *""'");
11452 }
11453 arg1 = reinterpret_cast< wxChar * >(argp1);
11454 {
11455 PyThreadState* __tstate = wxPyBeginAllowThreads();
11456 wxLog::SetTimestamp((wxChar const *)arg1);
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 resultobj = SWIG_Py_Void();
11461 return resultobj;
11462 fail:
11463 return NULL;
11464 }
11465
11466
11467 SWIGINTERN PyObject *_wrap_Log_GetVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11468 PyObject *resultobj = 0;
11469 bool result;
11470
11471 if (!SWIG_Python_UnpackTuple(args,"Log_GetVerbose",0,0,0)) SWIG_fail;
11472 {
11473 PyThreadState* __tstate = wxPyBeginAllowThreads();
11474 result = (bool)wxLog::GetVerbose();
11475 wxPyEndAllowThreads(__tstate);
11476 if (PyErr_Occurred()) SWIG_fail;
11477 }
11478 {
11479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11480 }
11481 return resultobj;
11482 fail:
11483 return NULL;
11484 }
11485
11486
11487 SWIGINTERN PyObject *_wrap_Log_GetTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11488 PyObject *resultobj = 0;
11489 wxTraceMask result;
11490
11491 if (!SWIG_Python_UnpackTuple(args,"Log_GetTraceMask",0,0,0)) SWIG_fail;
11492 {
11493 PyThreadState* __tstate = wxPyBeginAllowThreads();
11494 result = (wxTraceMask)wxLog::GetTraceMask();
11495 wxPyEndAllowThreads(__tstate);
11496 if (PyErr_Occurred()) SWIG_fail;
11497 }
11498 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11499 return resultobj;
11500 fail:
11501 return NULL;
11502 }
11503
11504
11505 SWIGINTERN PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11506 PyObject *resultobj = 0;
11507 wxChar *arg1 = (wxChar *) 0 ;
11508 bool result;
11509 void *argp1 = 0 ;
11510 int res1 = 0 ;
11511 PyObject * obj0 = 0 ;
11512 char * kwnames[] = {
11513 (char *) "mask", NULL
11514 };
11515
11516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) SWIG_fail;
11517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxChar, 0 | 0 );
11518 if (!SWIG_IsOK(res1)) {
11519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_IsAllowedTraceMask" "', expected argument " "1"" of type '" "wxChar const *""'");
11520 }
11521 arg1 = reinterpret_cast< wxChar * >(argp1);
11522 {
11523 PyThreadState* __tstate = wxPyBeginAllowThreads();
11524 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
11525 wxPyEndAllowThreads(__tstate);
11526 if (PyErr_Occurred()) SWIG_fail;
11527 }
11528 {
11529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11530 }
11531 return resultobj;
11532 fail:
11533 return NULL;
11534 }
11535
11536
11537 SWIGINTERN PyObject *_wrap_Log_GetLogLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11538 PyObject *resultobj = 0;
11539 wxLogLevel result;
11540
11541 if (!SWIG_Python_UnpackTuple(args,"Log_GetLogLevel",0,0,0)) SWIG_fail;
11542 {
11543 PyThreadState* __tstate = wxPyBeginAllowThreads();
11544 result = (wxLogLevel)wxLog::GetLogLevel();
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 SWIGINTERN PyObject *_wrap_Log_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11556 PyObject *resultobj = 0;
11557 wxChar *result = 0 ;
11558
11559 if (!SWIG_Python_UnpackTuple(args,"Log_GetTimestamp",0,0,0)) SWIG_fail;
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 result = (wxChar *)wxLog::GetTimestamp();
11563 wxPyEndAllowThreads(__tstate);
11564 if (PyErr_Occurred()) SWIG_fail;
11565 }
11566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChar, 0 | 0 );
11567 return resultobj;
11568 fail:
11569 return NULL;
11570 }
11571
11572
11573 SWIGINTERN PyObject *_wrap_Log_TimeStamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11574 PyObject *resultobj = 0;
11575 wxString result;
11576
11577 if (!SWIG_Python_UnpackTuple(args,"Log_TimeStamp",0,0,0)) SWIG_fail;
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 result = wxLog_TimeStamp();
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 {
11585 #if wxUSE_UNICODE
11586 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11587 #else
11588 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11589 #endif
11590 }
11591 return resultobj;
11592 fail:
11593 return NULL;
11594 }
11595
11596
11597 SWIGINTERN PyObject *_wrap_Log_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11598 PyObject *resultobj = 0;
11599 wxLog *arg1 = (wxLog *) 0 ;
11600 void *argp1 = 0 ;
11601 int res1 = 0 ;
11602 PyObject *swig_obj[1] ;
11603
11604 if (!args) SWIG_fail;
11605 swig_obj[0] = args;
11606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11607 if (!SWIG_IsOK(res1)) {
11608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Log_Destroy" "', expected argument " "1"" of type '" "wxLog *""'");
11609 }
11610 arg1 = reinterpret_cast< wxLog * >(argp1);
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 wxLog_Destroy(arg1);
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 resultobj = SWIG_Py_Void();
11618 return resultobj;
11619 fail:
11620 return NULL;
11621 }
11622
11623
11624 SWIGINTERN PyObject *Log_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11625 PyObject *obj;
11626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11627 SWIG_TypeNewClientData(SWIGTYPE_p_wxLog, SWIG_NewClientData(obj));
11628 return SWIG_Py_Void();
11629 }
11630
11631 SWIGINTERN PyObject *Log_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11632 return SWIG_Python_InitShadowInstance(args);
11633 }
11634
11635 SWIGINTERN PyObject *_wrap_new_LogStderr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11636 PyObject *resultobj = 0;
11637 wxLogStderr *result = 0 ;
11638
11639 if (!SWIG_Python_UnpackTuple(args,"new_LogStderr",0,0,0)) SWIG_fail;
11640 {
11641 PyThreadState* __tstate = wxPyBeginAllowThreads();
11642 result = (wxLogStderr *)new wxLogStderr();
11643 wxPyEndAllowThreads(__tstate);
11644 if (PyErr_Occurred()) SWIG_fail;
11645 }
11646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogStderr, SWIG_POINTER_NEW | 0 );
11647 return resultobj;
11648 fail:
11649 return NULL;
11650 }
11651
11652
11653 SWIGINTERN PyObject *LogStderr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11654 PyObject *obj;
11655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11656 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogStderr, SWIG_NewClientData(obj));
11657 return SWIG_Py_Void();
11658 }
11659
11660 SWIGINTERN PyObject *LogStderr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11661 return SWIG_Python_InitShadowInstance(args);
11662 }
11663
11664 SWIGINTERN PyObject *_wrap_new_LogTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11665 PyObject *resultobj = 0;
11666 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
11667 wxLogTextCtrl *result = 0 ;
11668 void *argp1 = 0 ;
11669 int res1 = 0 ;
11670 PyObject * obj0 = 0 ;
11671 char * kwnames[] = {
11672 (char *) "pTextCtrl", NULL
11673 };
11674
11675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) SWIG_fail;
11676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextCtrl, 0 | 0 );
11677 if (!SWIG_IsOK(res1)) {
11678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogTextCtrl" "', expected argument " "1"" of type '" "wxTextCtrl *""'");
11679 }
11680 arg1 = reinterpret_cast< wxTextCtrl * >(argp1);
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
11684 wxPyEndAllowThreads(__tstate);
11685 if (PyErr_Occurred()) SWIG_fail;
11686 }
11687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogTextCtrl, SWIG_POINTER_NEW | 0 );
11688 return resultobj;
11689 fail:
11690 return NULL;
11691 }
11692
11693
11694 SWIGINTERN PyObject *LogTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11695 PyObject *obj;
11696 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11697 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogTextCtrl, SWIG_NewClientData(obj));
11698 return SWIG_Py_Void();
11699 }
11700
11701 SWIGINTERN PyObject *LogTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11702 return SWIG_Python_InitShadowInstance(args);
11703 }
11704
11705 SWIGINTERN PyObject *_wrap_new_LogGui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11706 PyObject *resultobj = 0;
11707 wxLogGui *result = 0 ;
11708
11709 if (!SWIG_Python_UnpackTuple(args,"new_LogGui",0,0,0)) SWIG_fail;
11710 {
11711 PyThreadState* __tstate = wxPyBeginAllowThreads();
11712 result = (wxLogGui *)new wxLogGui();
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogGui, SWIG_POINTER_NEW | 0 );
11717 return resultobj;
11718 fail:
11719 return NULL;
11720 }
11721
11722
11723 SWIGINTERN PyObject *LogGui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11724 PyObject *obj;
11725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11726 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogGui, SWIG_NewClientData(obj));
11727 return SWIG_Py_Void();
11728 }
11729
11730 SWIGINTERN PyObject *LogGui_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11731 return SWIG_Python_InitShadowInstance(args);
11732 }
11733
11734 SWIGINTERN PyObject *_wrap_new_LogWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11735 PyObject *resultobj = 0;
11736 wxFrame *arg1 = (wxFrame *) 0 ;
11737 wxString *arg2 = 0 ;
11738 bool arg3 = (bool) true ;
11739 bool arg4 = (bool) true ;
11740 wxLogWindow *result = 0 ;
11741 void *argp1 = 0 ;
11742 int res1 = 0 ;
11743 bool temp2 = false ;
11744 bool val3 ;
11745 int ecode3 = 0 ;
11746 bool val4 ;
11747 int ecode4 = 0 ;
11748 PyObject * obj0 = 0 ;
11749 PyObject * obj1 = 0 ;
11750 PyObject * obj2 = 0 ;
11751 PyObject * obj3 = 0 ;
11752 char * kwnames[] = {
11753 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
11754 };
11755
11756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
11757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
11758 if (!SWIG_IsOK(res1)) {
11759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogWindow" "', expected argument " "1"" of type '" "wxFrame *""'");
11760 }
11761 arg1 = reinterpret_cast< wxFrame * >(argp1);
11762 {
11763 arg2 = wxString_in_helper(obj1);
11764 if (arg2 == NULL) SWIG_fail;
11765 temp2 = true;
11766 }
11767 if (obj2) {
11768 ecode3 = SWIG_AsVal_bool(obj2, &val3);
11769 if (!SWIG_IsOK(ecode3)) {
11770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogWindow" "', expected argument " "3"" of type '" "bool""'");
11771 }
11772 arg3 = static_cast< bool >(val3);
11773 }
11774 if (obj3) {
11775 ecode4 = SWIG_AsVal_bool(obj3, &val4);
11776 if (!SWIG_IsOK(ecode4)) {
11777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogWindow" "', expected argument " "4"" of type '" "bool""'");
11778 }
11779 arg4 = static_cast< bool >(val4);
11780 }
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
11784 wxPyEndAllowThreads(__tstate);
11785 if (PyErr_Occurred()) SWIG_fail;
11786 }
11787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogWindow, SWIG_POINTER_NEW | 0 );
11788 {
11789 if (temp2)
11790 delete arg2;
11791 }
11792 return resultobj;
11793 fail:
11794 {
11795 if (temp2)
11796 delete arg2;
11797 }
11798 return NULL;
11799 }
11800
11801
11802 SWIGINTERN PyObject *_wrap_LogWindow_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11803 PyObject *resultobj = 0;
11804 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11805 bool arg2 = (bool) true ;
11806 void *argp1 = 0 ;
11807 int res1 = 0 ;
11808 bool val2 ;
11809 int ecode2 = 0 ;
11810 PyObject * obj0 = 0 ;
11811 PyObject * obj1 = 0 ;
11812 char * kwnames[] = {
11813 (char *) "self",(char *) "bShow", NULL
11814 };
11815
11816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) SWIG_fail;
11817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11818 if (!SWIG_IsOK(res1)) {
11819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_Show" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11820 }
11821 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11822 if (obj1) {
11823 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11824 if (!SWIG_IsOK(ecode2)) {
11825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_Show" "', expected argument " "2"" of type '" "bool""'");
11826 }
11827 arg2 = static_cast< bool >(val2);
11828 }
11829 {
11830 PyThreadState* __tstate = wxPyBeginAllowThreads();
11831 (arg1)->Show(arg2);
11832 wxPyEndAllowThreads(__tstate);
11833 if (PyErr_Occurred()) SWIG_fail;
11834 }
11835 resultobj = SWIG_Py_Void();
11836 return resultobj;
11837 fail:
11838 return NULL;
11839 }
11840
11841
11842 SWIGINTERN PyObject *_wrap_LogWindow_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11843 PyObject *resultobj = 0;
11844 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11845 wxFrame *result = 0 ;
11846 void *argp1 = 0 ;
11847 int res1 = 0 ;
11848 PyObject *swig_obj[1] ;
11849
11850 if (!args) SWIG_fail;
11851 swig_obj[0] = args;
11852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11853 if (!SWIG_IsOK(res1)) {
11854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetFrame" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11855 }
11856 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11857 {
11858 PyThreadState* __tstate = wxPyBeginAllowThreads();
11859 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
11860 wxPyEndAllowThreads(__tstate);
11861 if (PyErr_Occurred()) SWIG_fail;
11862 }
11863 {
11864 resultobj = wxPyMake_wxObject(result, (bool)0);
11865 }
11866 return resultobj;
11867 fail:
11868 return NULL;
11869 }
11870
11871
11872 SWIGINTERN PyObject *_wrap_LogWindow_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11873 PyObject *resultobj = 0;
11874 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11875 wxLog *result = 0 ;
11876 void *argp1 = 0 ;
11877 int res1 = 0 ;
11878 PyObject *swig_obj[1] ;
11879
11880 if (!args) SWIG_fail;
11881 swig_obj[0] = args;
11882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11883 if (!SWIG_IsOK(res1)) {
11884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_GetOldLog" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11885 }
11886 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11887 {
11888 PyThreadState* __tstate = wxPyBeginAllowThreads();
11889 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
11890 wxPyEndAllowThreads(__tstate);
11891 if (PyErr_Occurred()) SWIG_fail;
11892 }
11893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
11894 return resultobj;
11895 fail:
11896 return NULL;
11897 }
11898
11899
11900 SWIGINTERN PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11901 PyObject *resultobj = 0;
11902 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11903 bool result;
11904 void *argp1 = 0 ;
11905 int res1 = 0 ;
11906 PyObject *swig_obj[1] ;
11907
11908 if (!args) SWIG_fail;
11909 swig_obj[0] = args;
11910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11911 if (!SWIG_IsOK(res1)) {
11912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogWindow const *""'");
11913 }
11914 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
11918 wxPyEndAllowThreads(__tstate);
11919 if (PyErr_Occurred()) SWIG_fail;
11920 }
11921 {
11922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11923 }
11924 return resultobj;
11925 fail:
11926 return NULL;
11927 }
11928
11929
11930 SWIGINTERN PyObject *_wrap_LogWindow_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11931 PyObject *resultobj = 0;
11932 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
11933 bool arg2 ;
11934 void *argp1 = 0 ;
11935 int res1 = 0 ;
11936 bool val2 ;
11937 int ecode2 = 0 ;
11938 PyObject * obj0 = 0 ;
11939 PyObject * obj1 = 0 ;
11940 char * kwnames[] = {
11941 (char *) "self",(char *) "bDoPass", NULL
11942 };
11943
11944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
11945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogWindow, 0 | 0 );
11946 if (!SWIG_IsOK(res1)) {
11947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogWindow_PassMessages" "', expected argument " "1"" of type '" "wxLogWindow *""'");
11948 }
11949 arg1 = reinterpret_cast< wxLogWindow * >(argp1);
11950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
11951 if (!SWIG_IsOK(ecode2)) {
11952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogWindow_PassMessages" "', expected argument " "2"" of type '" "bool""'");
11953 }
11954 arg2 = static_cast< bool >(val2);
11955 {
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 (arg1)->PassMessages(arg2);
11958 wxPyEndAllowThreads(__tstate);
11959 if (PyErr_Occurred()) SWIG_fail;
11960 }
11961 resultobj = SWIG_Py_Void();
11962 return resultobj;
11963 fail:
11964 return NULL;
11965 }
11966
11967
11968 SWIGINTERN PyObject *LogWindow_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11969 PyObject *obj;
11970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11971 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogWindow, SWIG_NewClientData(obj));
11972 return SWIG_Py_Void();
11973 }
11974
11975 SWIGINTERN PyObject *LogWindow_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11976 return SWIG_Python_InitShadowInstance(args);
11977 }
11978
11979 SWIGINTERN PyObject *_wrap_new_LogChain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11980 PyObject *resultobj = 0;
11981 wxLog *arg1 = (wxLog *) 0 ;
11982 wxLogChain *result = 0 ;
11983 void *argp1 = 0 ;
11984 int res1 = 0 ;
11985 PyObject * obj0 = 0 ;
11986 char * kwnames[] = {
11987 (char *) "logger", NULL
11988 };
11989
11990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) SWIG_fail;
11991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLog, 0 | 0 );
11992 if (!SWIG_IsOK(res1)) {
11993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogChain" "', expected argument " "1"" of type '" "wxLog *""'");
11994 }
11995 arg1 = reinterpret_cast< wxLog * >(argp1);
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (wxLogChain *)new wxLogChain(arg1);
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogChain, SWIG_POINTER_NEW | 0 );
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 SWIGINTERN PyObject *_wrap_LogChain_SetLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12010 PyObject *resultobj = 0;
12011 wxLogChain *arg1 = (wxLogChain *) 0 ;
12012 wxLog *arg2 = (wxLog *) 0 ;
12013 void *argp1 = 0 ;
12014 int res1 = 0 ;
12015 void *argp2 = 0 ;
12016 int res2 = 0 ;
12017 PyObject * obj0 = 0 ;
12018 PyObject * obj1 = 0 ;
12019 char * kwnames[] = {
12020 (char *) "self",(char *) "logger", NULL
12021 };
12022
12023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) SWIG_fail;
12024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12025 if (!SWIG_IsOK(res1)) {
12026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_SetLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12027 }
12028 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12029 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLog, 0 | 0 );
12030 if (!SWIG_IsOK(res2)) {
12031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogChain_SetLog" "', expected argument " "2"" of type '" "wxLog *""'");
12032 }
12033 arg2 = reinterpret_cast< wxLog * >(argp2);
12034 {
12035 PyThreadState* __tstate = wxPyBeginAllowThreads();
12036 (arg1)->SetLog(arg2);
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 resultobj = SWIG_Py_Void();
12041 return resultobj;
12042 fail:
12043 return NULL;
12044 }
12045
12046
12047 SWIGINTERN PyObject *_wrap_LogChain_PassMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12048 PyObject *resultobj = 0;
12049 wxLogChain *arg1 = (wxLogChain *) 0 ;
12050 bool arg2 ;
12051 void *argp1 = 0 ;
12052 int res1 = 0 ;
12053 bool val2 ;
12054 int ecode2 = 0 ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 char * kwnames[] = {
12058 (char *) "self",(char *) "bDoPass", NULL
12059 };
12060
12061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) SWIG_fail;
12062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12063 if (!SWIG_IsOK(res1)) {
12064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_PassMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12065 }
12066 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12067 ecode2 = SWIG_AsVal_bool(obj1, &val2);
12068 if (!SWIG_IsOK(ecode2)) {
12069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogChain_PassMessages" "', expected argument " "2"" of type '" "bool""'");
12070 }
12071 arg2 = static_cast< bool >(val2);
12072 {
12073 PyThreadState* __tstate = wxPyBeginAllowThreads();
12074 (arg1)->PassMessages(arg2);
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 resultobj = SWIG_Py_Void();
12079 return resultobj;
12080 fail:
12081 return NULL;
12082 }
12083
12084
12085 SWIGINTERN PyObject *_wrap_LogChain_IsPassingMessages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12086 PyObject *resultobj = 0;
12087 wxLogChain *arg1 = (wxLogChain *) 0 ;
12088 bool result;
12089 void *argp1 = 0 ;
12090 int res1 = 0 ;
12091 PyObject *swig_obj[1] ;
12092
12093 if (!args) SWIG_fail;
12094 swig_obj[0] = args;
12095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12096 if (!SWIG_IsOK(res1)) {
12097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_IsPassingMessages" "', expected argument " "1"" of type '" "wxLogChain *""'");
12098 }
12099 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12100 {
12101 PyThreadState* __tstate = wxPyBeginAllowThreads();
12102 result = (bool)(arg1)->IsPassingMessages();
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 {
12107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12108 }
12109 return resultobj;
12110 fail:
12111 return NULL;
12112 }
12113
12114
12115 SWIGINTERN PyObject *_wrap_LogChain_GetOldLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12116 PyObject *resultobj = 0;
12117 wxLogChain *arg1 = (wxLogChain *) 0 ;
12118 wxLog *result = 0 ;
12119 void *argp1 = 0 ;
12120 int res1 = 0 ;
12121 PyObject *swig_obj[1] ;
12122
12123 if (!args) SWIG_fail;
12124 swig_obj[0] = args;
12125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogChain, 0 | 0 );
12126 if (!SWIG_IsOK(res1)) {
12127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogChain_GetOldLog" "', expected argument " "1"" of type '" "wxLogChain *""'");
12128 }
12129 arg1 = reinterpret_cast< wxLogChain * >(argp1);
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 result = (wxLog *)(arg1)->GetOldLog();
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLog, 0 | 0 );
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *LogChain_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12144 PyObject *obj;
12145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12146 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogChain, SWIG_NewClientData(obj));
12147 return SWIG_Py_Void();
12148 }
12149
12150 SWIGINTERN PyObject *LogChain_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12151 return SWIG_Python_InitShadowInstance(args);
12152 }
12153
12154 SWIGINTERN PyObject *_wrap_new_LogBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12155 PyObject *resultobj = 0;
12156 wxLogBuffer *result = 0 ;
12157
12158 if (!SWIG_Python_UnpackTuple(args,"new_LogBuffer",0,0,0)) SWIG_fail;
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (wxLogBuffer *)new wxLogBuffer();
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogBuffer, SWIG_POINTER_NEW | 0 );
12166 return resultobj;
12167 fail:
12168 return NULL;
12169 }
12170
12171
12172 SWIGINTERN PyObject *_wrap_LogBuffer_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12173 PyObject *resultobj = 0;
12174 wxLogBuffer *arg1 = (wxLogBuffer *) 0 ;
12175 wxString *result = 0 ;
12176 void *argp1 = 0 ;
12177 int res1 = 0 ;
12178 PyObject *swig_obj[1] ;
12179
12180 if (!args) SWIG_fail;
12181 swig_obj[0] = args;
12182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogBuffer, 0 | 0 );
12183 if (!SWIG_IsOK(res1)) {
12184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogBuffer_GetBuffer" "', expected argument " "1"" of type '" "wxLogBuffer const *""'");
12185 }
12186 arg1 = reinterpret_cast< wxLogBuffer * >(argp1);
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 {
12190 wxString const &_result_ref = ((wxLogBuffer const *)arg1)->GetBuffer();
12191 result = (wxString *) &_result_ref;
12192 }
12193 wxPyEndAllowThreads(__tstate);
12194 if (PyErr_Occurred()) SWIG_fail;
12195 }
12196 {
12197 #if wxUSE_UNICODE
12198 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12199 #else
12200 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12201 #endif
12202 }
12203 return resultobj;
12204 fail:
12205 return NULL;
12206 }
12207
12208
12209 SWIGINTERN PyObject *LogBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12210 PyObject *obj;
12211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12212 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogBuffer, SWIG_NewClientData(obj));
12213 return SWIG_Py_Void();
12214 }
12215
12216 SWIGINTERN PyObject *LogBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12217 return SWIG_Python_InitShadowInstance(args);
12218 }
12219
12220 SWIGINTERN PyObject *_wrap_SysErrorCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12221 PyObject *resultobj = 0;
12222 unsigned long result;
12223
12224 if (!SWIG_Python_UnpackTuple(args,"SysErrorCode",0,0,0)) SWIG_fail;
12225 {
12226 PyThreadState* __tstate = wxPyBeginAllowThreads();
12227 result = (unsigned long)wxSysErrorCode();
12228 wxPyEndAllowThreads(__tstate);
12229 if (PyErr_Occurred()) SWIG_fail;
12230 }
12231 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12232 return resultobj;
12233 fail:
12234 return NULL;
12235 }
12236
12237
12238 SWIGINTERN PyObject *_wrap_SysErrorMsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12239 PyObject *resultobj = 0;
12240 unsigned long arg1 = (unsigned long) 0 ;
12241 wxString result;
12242 unsigned long val1 ;
12243 int ecode1 = 0 ;
12244 PyObject * obj0 = 0 ;
12245 char * kwnames[] = {
12246 (char *) "nErrCode", NULL
12247 };
12248
12249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) SWIG_fail;
12250 if (obj0) {
12251 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12252 if (!SWIG_IsOK(ecode1)) {
12253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SysErrorMsg" "', expected argument " "1"" of type '" "unsigned long""'");
12254 }
12255 arg1 = static_cast< unsigned long >(val1);
12256 }
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 result = wxSysErrorMsg(arg1);
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 {
12264 #if wxUSE_UNICODE
12265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12266 #else
12267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12268 #endif
12269 }
12270 return resultobj;
12271 fail:
12272 return NULL;
12273 }
12274
12275
12276 SWIGINTERN PyObject *_wrap_LogFatalError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12277 PyObject *resultobj = 0;
12278 wxString *arg1 = 0 ;
12279 bool temp1 = false ;
12280 PyObject * obj0 = 0 ;
12281 char * kwnames[] = {
12282 (char *) "msg", NULL
12283 };
12284
12285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) SWIG_fail;
12286 {
12287 arg1 = wxString_in_helper(obj0);
12288 if (arg1 == NULL) SWIG_fail;
12289 temp1 = true;
12290 }
12291 {
12292 PyThreadState* __tstate = wxPyBeginAllowThreads();
12293 wxPyLogFatalError((wxString const &)*arg1);
12294 wxPyEndAllowThreads(__tstate);
12295 if (PyErr_Occurred()) SWIG_fail;
12296 }
12297 resultobj = SWIG_Py_Void();
12298 {
12299 if (temp1)
12300 delete arg1;
12301 }
12302 return resultobj;
12303 fail:
12304 {
12305 if (temp1)
12306 delete arg1;
12307 }
12308 return NULL;
12309 }
12310
12311
12312 SWIGINTERN PyObject *_wrap_LogError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12313 PyObject *resultobj = 0;
12314 wxString *arg1 = 0 ;
12315 bool temp1 = false ;
12316 PyObject * obj0 = 0 ;
12317 char * kwnames[] = {
12318 (char *) "msg", NULL
12319 };
12320
12321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) SWIG_fail;
12322 {
12323 arg1 = wxString_in_helper(obj0);
12324 if (arg1 == NULL) SWIG_fail;
12325 temp1 = true;
12326 }
12327 {
12328 PyThreadState* __tstate = wxPyBeginAllowThreads();
12329 wxPyLogError((wxString const &)*arg1);
12330 wxPyEndAllowThreads(__tstate);
12331 if (PyErr_Occurred()) SWIG_fail;
12332 }
12333 resultobj = SWIG_Py_Void();
12334 {
12335 if (temp1)
12336 delete arg1;
12337 }
12338 return resultobj;
12339 fail:
12340 {
12341 if (temp1)
12342 delete arg1;
12343 }
12344 return NULL;
12345 }
12346
12347
12348 SWIGINTERN PyObject *_wrap_LogWarning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12349 PyObject *resultobj = 0;
12350 wxString *arg1 = 0 ;
12351 bool temp1 = false ;
12352 PyObject * obj0 = 0 ;
12353 char * kwnames[] = {
12354 (char *) "msg", NULL
12355 };
12356
12357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) SWIG_fail;
12358 {
12359 arg1 = wxString_in_helper(obj0);
12360 if (arg1 == NULL) SWIG_fail;
12361 temp1 = true;
12362 }
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 wxPyLogWarning((wxString const &)*arg1);
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 resultobj = SWIG_Py_Void();
12370 {
12371 if (temp1)
12372 delete arg1;
12373 }
12374 return resultobj;
12375 fail:
12376 {
12377 if (temp1)
12378 delete arg1;
12379 }
12380 return NULL;
12381 }
12382
12383
12384 SWIGINTERN PyObject *_wrap_LogMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj = 0;
12386 wxString *arg1 = 0 ;
12387 bool temp1 = false ;
12388 PyObject * obj0 = 0 ;
12389 char * kwnames[] = {
12390 (char *) "msg", NULL
12391 };
12392
12393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) SWIG_fail;
12394 {
12395 arg1 = wxString_in_helper(obj0);
12396 if (arg1 == NULL) SWIG_fail;
12397 temp1 = true;
12398 }
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 wxPyLogMessage((wxString const &)*arg1);
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 resultobj = SWIG_Py_Void();
12406 {
12407 if (temp1)
12408 delete arg1;
12409 }
12410 return resultobj;
12411 fail:
12412 {
12413 if (temp1)
12414 delete arg1;
12415 }
12416 return NULL;
12417 }
12418
12419
12420 SWIGINTERN PyObject *_wrap_LogInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12421 PyObject *resultobj = 0;
12422 wxString *arg1 = 0 ;
12423 bool temp1 = false ;
12424 PyObject * obj0 = 0 ;
12425 char * kwnames[] = {
12426 (char *) "msg", NULL
12427 };
12428
12429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) SWIG_fail;
12430 {
12431 arg1 = wxString_in_helper(obj0);
12432 if (arg1 == NULL) SWIG_fail;
12433 temp1 = true;
12434 }
12435 {
12436 PyThreadState* __tstate = wxPyBeginAllowThreads();
12437 wxPyLogInfo((wxString const &)*arg1);
12438 wxPyEndAllowThreads(__tstate);
12439 if (PyErr_Occurred()) SWIG_fail;
12440 }
12441 resultobj = SWIG_Py_Void();
12442 {
12443 if (temp1)
12444 delete arg1;
12445 }
12446 return resultobj;
12447 fail:
12448 {
12449 if (temp1)
12450 delete arg1;
12451 }
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_LogDebug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12457 PyObject *resultobj = 0;
12458 wxString *arg1 = 0 ;
12459 bool temp1 = false ;
12460 PyObject * obj0 = 0 ;
12461 char * kwnames[] = {
12462 (char *) "msg", NULL
12463 };
12464
12465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) SWIG_fail;
12466 {
12467 arg1 = wxString_in_helper(obj0);
12468 if (arg1 == NULL) SWIG_fail;
12469 temp1 = true;
12470 }
12471 {
12472 PyThreadState* __tstate = wxPyBeginAllowThreads();
12473 wxPyLogDebug((wxString const &)*arg1);
12474 wxPyEndAllowThreads(__tstate);
12475 if (PyErr_Occurred()) SWIG_fail;
12476 }
12477 resultobj = SWIG_Py_Void();
12478 {
12479 if (temp1)
12480 delete arg1;
12481 }
12482 return resultobj;
12483 fail:
12484 {
12485 if (temp1)
12486 delete arg1;
12487 }
12488 return NULL;
12489 }
12490
12491
12492 SWIGINTERN PyObject *_wrap_LogVerbose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12493 PyObject *resultobj = 0;
12494 wxString *arg1 = 0 ;
12495 bool temp1 = false ;
12496 PyObject * obj0 = 0 ;
12497 char * kwnames[] = {
12498 (char *) "msg", NULL
12499 };
12500
12501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) SWIG_fail;
12502 {
12503 arg1 = wxString_in_helper(obj0);
12504 if (arg1 == NULL) SWIG_fail;
12505 temp1 = true;
12506 }
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 wxPyLogVerbose((wxString const &)*arg1);
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 resultobj = SWIG_Py_Void();
12514 {
12515 if (temp1)
12516 delete arg1;
12517 }
12518 return resultobj;
12519 fail:
12520 {
12521 if (temp1)
12522 delete arg1;
12523 }
12524 return NULL;
12525 }
12526
12527
12528 SWIGINTERN PyObject *_wrap_LogStatus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj = 0;
12530 wxString *arg1 = 0 ;
12531 bool temp1 = false ;
12532 PyObject * obj0 = 0 ;
12533 char * kwnames[] = {
12534 (char *) "msg", NULL
12535 };
12536
12537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) SWIG_fail;
12538 {
12539 arg1 = wxString_in_helper(obj0);
12540 if (arg1 == NULL) SWIG_fail;
12541 temp1 = true;
12542 }
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 wxPyLogStatus((wxString const &)*arg1);
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 resultobj = SWIG_Py_Void();
12550 {
12551 if (temp1)
12552 delete arg1;
12553 }
12554 return resultobj;
12555 fail:
12556 {
12557 if (temp1)
12558 delete arg1;
12559 }
12560 return NULL;
12561 }
12562
12563
12564 SWIGINTERN PyObject *_wrap_LogStatusFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12565 PyObject *resultobj = 0;
12566 wxFrame *arg1 = (wxFrame *) 0 ;
12567 wxString *arg2 = 0 ;
12568 void *argp1 = 0 ;
12569 int res1 = 0 ;
12570 bool temp2 = false ;
12571 PyObject * obj0 = 0 ;
12572 PyObject * obj1 = 0 ;
12573 char * kwnames[] = {
12574 (char *) "pFrame",(char *) "msg", NULL
12575 };
12576
12577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) SWIG_fail;
12578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFrame, 0 | 0 );
12579 if (!SWIG_IsOK(res1)) {
12580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogStatusFrame" "', expected argument " "1"" of type '" "wxFrame *""'");
12581 }
12582 arg1 = reinterpret_cast< wxFrame * >(argp1);
12583 {
12584 arg2 = wxString_in_helper(obj1);
12585 if (arg2 == NULL) SWIG_fail;
12586 temp2 = true;
12587 }
12588 {
12589 PyThreadState* __tstate = wxPyBeginAllowThreads();
12590 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
12591 wxPyEndAllowThreads(__tstate);
12592 if (PyErr_Occurred()) SWIG_fail;
12593 }
12594 resultobj = SWIG_Py_Void();
12595 {
12596 if (temp2)
12597 delete arg2;
12598 }
12599 return resultobj;
12600 fail:
12601 {
12602 if (temp2)
12603 delete arg2;
12604 }
12605 return NULL;
12606 }
12607
12608
12609 SWIGINTERN PyObject *_wrap_LogSysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12610 PyObject *resultobj = 0;
12611 wxString *arg1 = 0 ;
12612 bool temp1 = false ;
12613 PyObject * obj0 = 0 ;
12614 char * kwnames[] = {
12615 (char *) "msg", NULL
12616 };
12617
12618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) SWIG_fail;
12619 {
12620 arg1 = wxString_in_helper(obj0);
12621 if (arg1 == NULL) SWIG_fail;
12622 temp1 = true;
12623 }
12624 {
12625 PyThreadState* __tstate = wxPyBeginAllowThreads();
12626 wxPyLogSysError((wxString const &)*arg1);
12627 wxPyEndAllowThreads(__tstate);
12628 if (PyErr_Occurred()) SWIG_fail;
12629 }
12630 resultobj = SWIG_Py_Void();
12631 {
12632 if (temp1)
12633 delete arg1;
12634 }
12635 return resultobj;
12636 fail:
12637 {
12638 if (temp1)
12639 delete arg1;
12640 }
12641 return NULL;
12642 }
12643
12644
12645 SWIGINTERN PyObject *_wrap_LogGeneric(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12646 PyObject *resultobj = 0;
12647 unsigned long arg1 ;
12648 wxString *arg2 = 0 ;
12649 unsigned long val1 ;
12650 int ecode1 = 0 ;
12651 bool temp2 = false ;
12652 PyObject * obj0 = 0 ;
12653 PyObject * obj1 = 0 ;
12654 char * kwnames[] = {
12655 (char *) "level",(char *) "msg", NULL
12656 };
12657
12658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) SWIG_fail;
12659 ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
12660 if (!SWIG_IsOK(ecode1)) {
12661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogGeneric" "', expected argument " "1"" of type '" "unsigned long""'");
12662 }
12663 arg1 = static_cast< unsigned long >(val1);
12664 {
12665 arg2 = wxString_in_helper(obj1);
12666 if (arg2 == NULL) SWIG_fail;
12667 temp2 = true;
12668 }
12669 {
12670 PyThreadState* __tstate = wxPyBeginAllowThreads();
12671 wxPyLogGeneric(arg1,(wxString const &)*arg2);
12672 wxPyEndAllowThreads(__tstate);
12673 if (PyErr_Occurred()) SWIG_fail;
12674 }
12675 resultobj = SWIG_Py_Void();
12676 {
12677 if (temp2)
12678 delete arg2;
12679 }
12680 return resultobj;
12681 fail:
12682 {
12683 if (temp2)
12684 delete arg2;
12685 }
12686 return NULL;
12687 }
12688
12689
12690 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12691 PyObject *resultobj = 0;
12692 unsigned long arg1 ;
12693 wxString *arg2 = 0 ;
12694 unsigned long val1 ;
12695 int ecode1 = 0 ;
12696 bool temp2 = false ;
12697
12698 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12699 ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1);
12700 if (!SWIG_IsOK(ecode1)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LogTrace" "', expected argument " "1"" of type '" "unsigned long""'");
12702 }
12703 arg1 = static_cast< unsigned long >(val1);
12704 {
12705 arg2 = wxString_in_helper(swig_obj[1]);
12706 if (arg2 == NULL) SWIG_fail;
12707 temp2 = true;
12708 }
12709 {
12710 PyThreadState* __tstate = wxPyBeginAllowThreads();
12711 wxPyLogTrace(arg1,(wxString const &)*arg2);
12712 wxPyEndAllowThreads(__tstate);
12713 if (PyErr_Occurred()) SWIG_fail;
12714 }
12715 resultobj = SWIG_Py_Void();
12716 {
12717 if (temp2)
12718 delete arg2;
12719 }
12720 return resultobj;
12721 fail:
12722 {
12723 if (temp2)
12724 delete arg2;
12725 }
12726 return NULL;
12727 }
12728
12729
12730 SWIGINTERN PyObject *_wrap_LogTrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
12731 PyObject *resultobj = 0;
12732 wxString *arg1 = 0 ;
12733 wxString *arg2 = 0 ;
12734 bool temp1 = false ;
12735 bool temp2 = false ;
12736
12737 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
12738 {
12739 arg1 = wxString_in_helper(swig_obj[0]);
12740 if (arg1 == NULL) SWIG_fail;
12741 temp1 = true;
12742 }
12743 {
12744 arg2 = wxString_in_helper(swig_obj[1]);
12745 if (arg2 == NULL) SWIG_fail;
12746 temp2 = true;
12747 }
12748 {
12749 PyThreadState* __tstate = wxPyBeginAllowThreads();
12750 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 resultobj = SWIG_Py_Void();
12755 {
12756 if (temp1)
12757 delete arg1;
12758 }
12759 {
12760 if (temp2)
12761 delete arg2;
12762 }
12763 return resultobj;
12764 fail:
12765 {
12766 if (temp1)
12767 delete arg1;
12768 }
12769 {
12770 if (temp2)
12771 delete arg2;
12772 }
12773 return NULL;
12774 }
12775
12776
12777 SWIGINTERN PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
12778 int argc;
12779 PyObject *argv[3];
12780
12781 if (!(argc = SWIG_Python_UnpackTuple(args,"LogTrace",0,2,argv))) SWIG_fail;
12782 --argc;
12783 if (argc == 2) {
12784 int _v = 0;
12785 {
12786 {
12787 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
12788 }
12789 }
12790 if (!_v) goto check_1;
12791 return _wrap_LogTrace__SWIG_1(self, argc, argv);
12792 }
12793 check_1:
12794
12795 if (argc == 2) {
12796 return _wrap_LogTrace__SWIG_0(self, argc, argv);
12797 }
12798
12799 fail:
12800 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
12801 return NULL;
12802 }
12803
12804
12805 SWIGINTERN PyObject *_wrap_SafeShowMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12806 PyObject *resultobj = 0;
12807 wxString *arg1 = 0 ;
12808 wxString *arg2 = 0 ;
12809 bool temp1 = false ;
12810 bool temp2 = false ;
12811 PyObject * obj0 = 0 ;
12812 PyObject * obj1 = 0 ;
12813 char * kwnames[] = {
12814 (char *) "title",(char *) "text", NULL
12815 };
12816
12817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) SWIG_fail;
12818 {
12819 arg1 = wxString_in_helper(obj0);
12820 if (arg1 == NULL) SWIG_fail;
12821 temp1 = true;
12822 }
12823 {
12824 arg2 = wxString_in_helper(obj1);
12825 if (arg2 == NULL) SWIG_fail;
12826 temp2 = true;
12827 }
12828 {
12829 PyThreadState* __tstate = wxPyBeginAllowThreads();
12830 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 resultobj = SWIG_Py_Void();
12835 {
12836 if (temp1)
12837 delete arg1;
12838 }
12839 {
12840 if (temp2)
12841 delete arg2;
12842 }
12843 return resultobj;
12844 fail:
12845 {
12846 if (temp1)
12847 delete arg1;
12848 }
12849 {
12850 if (temp2)
12851 delete arg2;
12852 }
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *_wrap_new_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12858 PyObject *resultobj = 0;
12859 wxLogNull *result = 0 ;
12860
12861 if (!SWIG_Python_UnpackTuple(args,"new_LogNull",0,0,0)) SWIG_fail;
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 result = (wxLogNull *)new wxLogNull();
12865 wxPyEndAllowThreads(__tstate);
12866 if (PyErr_Occurred()) SWIG_fail;
12867 }
12868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLogNull, SWIG_POINTER_NEW | 0 );
12869 return resultobj;
12870 fail:
12871 return NULL;
12872 }
12873
12874
12875 SWIGINTERN PyObject *_wrap_delete_LogNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12876 PyObject *resultobj = 0;
12877 wxLogNull *arg1 = (wxLogNull *) 0 ;
12878 void *argp1 = 0 ;
12879 int res1 = 0 ;
12880 PyObject *swig_obj[1] ;
12881
12882 if (!args) SWIG_fail;
12883 swig_obj[0] = args;
12884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLogNull, SWIG_POINTER_DISOWN | 0 );
12885 if (!SWIG_IsOK(res1)) {
12886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogNull" "', expected argument " "1"" of type '" "wxLogNull *""'");
12887 }
12888 arg1 = reinterpret_cast< wxLogNull * >(argp1);
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 delete arg1;
12892
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 resultobj = SWIG_Py_Void();
12897 return resultobj;
12898 fail:
12899 return NULL;
12900 }
12901
12902
12903 SWIGINTERN PyObject *LogNull_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12904 PyObject *obj;
12905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12906 SWIG_TypeNewClientData(SWIGTYPE_p_wxLogNull, SWIG_NewClientData(obj));
12907 return SWIG_Py_Void();
12908 }
12909
12910 SWIGINTERN PyObject *LogNull_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12911 return SWIG_Python_InitShadowInstance(args);
12912 }
12913
12914 SWIGINTERN PyObject *_wrap_new_PyLog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12915 PyObject *resultobj = 0;
12916 wxPyLog *result = 0 ;
12917
12918 if (!SWIG_Python_UnpackTuple(args,"new_PyLog",0,0,0)) SWIG_fail;
12919 {
12920 PyThreadState* __tstate = wxPyBeginAllowThreads();
12921 result = (wxPyLog *)new wxPyLog();
12922 wxPyEndAllowThreads(__tstate);
12923 if (PyErr_Occurred()) SWIG_fail;
12924 }
12925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyLog, SWIG_POINTER_NEW | 0 );
12926 return resultobj;
12927 fail:
12928 return NULL;
12929 }
12930
12931
12932 SWIGINTERN PyObject *_wrap_PyLog__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12933 PyObject *resultobj = 0;
12934 wxPyLog *arg1 = (wxPyLog *) 0 ;
12935 PyObject *arg2 = (PyObject *) 0 ;
12936 PyObject *arg3 = (PyObject *) 0 ;
12937 void *argp1 = 0 ;
12938 int res1 = 0 ;
12939 PyObject * obj0 = 0 ;
12940 PyObject * obj1 = 0 ;
12941 PyObject * obj2 = 0 ;
12942 char * kwnames[] = {
12943 (char *) "self",(char *) "self",(char *) "_class", NULL
12944 };
12945
12946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyLog, 0 | 0 );
12948 if (!SWIG_IsOK(res1)) {
12949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyLog__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyLog *""'");
12950 }
12951 arg1 = reinterpret_cast< wxPyLog * >(argp1);
12952 arg2 = obj1;
12953 arg3 = obj2;
12954 {
12955 PyThreadState* __tstate = wxPyBeginAllowThreads();
12956 (arg1)->_setCallbackInfo(arg2,arg3);
12957 wxPyEndAllowThreads(__tstate);
12958 if (PyErr_Occurred()) SWIG_fail;
12959 }
12960 resultobj = SWIG_Py_Void();
12961 return resultobj;
12962 fail:
12963 return NULL;
12964 }
12965
12966
12967 SWIGINTERN PyObject *PyLog_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 PyObject *obj;
12969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12970 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyLog, SWIG_NewClientData(obj));
12971 return SWIG_Py_Void();
12972 }
12973
12974 SWIGINTERN PyObject *PyLog_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12975 return SWIG_Python_InitShadowInstance(args);
12976 }
12977
12978 SWIGINTERN PyObject *_wrap_Process_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12979 PyObject *resultobj = 0;
12980 int arg1 ;
12981 wxSignal arg2 = (wxSignal) wxSIGTERM ;
12982 int arg3 = (int) wxKILL_NOCHILDREN ;
12983 wxKillError result;
12984 int val1 ;
12985 int ecode1 = 0 ;
12986 int val2 ;
12987 int ecode2 = 0 ;
12988 int val3 ;
12989 int ecode3 = 0 ;
12990 PyObject * obj0 = 0 ;
12991 PyObject * obj1 = 0 ;
12992 PyObject * obj2 = 0 ;
12993 char * kwnames[] = {
12994 (char *) "pid",(char *) "sig",(char *) "flags", NULL
12995 };
12996
12997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12998 ecode1 = SWIG_AsVal_int(obj0, &val1);
12999 if (!SWIG_IsOK(ecode1)) {
13000 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Kill" "', expected argument " "1"" of type '" "int""'");
13001 }
13002 arg1 = static_cast< int >(val1);
13003 if (obj1) {
13004 ecode2 = SWIG_AsVal_int(obj1, &val2);
13005 if (!SWIG_IsOK(ecode2)) {
13006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13007 }
13008 arg2 = static_cast< wxSignal >(val2);
13009 }
13010 if (obj2) {
13011 ecode3 = SWIG_AsVal_int(obj2, &val3);
13012 if (!SWIG_IsOK(ecode3)) {
13013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_Kill" "', expected argument " "3"" of type '" "int""'");
13014 }
13015 arg3 = static_cast< int >(val3);
13016 }
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (wxKillError)wxPyProcess::Kill(arg1,arg2,arg3);
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 resultobj = SWIG_From_int(static_cast< int >(result));
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_Process_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13031 PyObject *resultobj = 0;
13032 int arg1 ;
13033 bool result;
13034 int val1 ;
13035 int ecode1 = 0 ;
13036 PyObject * obj0 = 0 ;
13037 char * kwnames[] = {
13038 (char *) "pid", NULL
13039 };
13040
13041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) SWIG_fail;
13042 ecode1 = SWIG_AsVal_int(obj0, &val1);
13043 if (!SWIG_IsOK(ecode1)) {
13044 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Process_Exists" "', expected argument " "1"" of type '" "int""'");
13045 }
13046 arg1 = static_cast< int >(val1);
13047 {
13048 PyThreadState* __tstate = wxPyBeginAllowThreads();
13049 result = (bool)wxPyProcess::Exists(arg1);
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 {
13054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13055 }
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 SWIGINTERN PyObject *_wrap_Process_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13063 PyObject *resultobj = 0;
13064 wxString *arg1 = 0 ;
13065 int arg2 = (int) wxEXEC_ASYNC ;
13066 wxPyProcess *result = 0 ;
13067 bool temp1 = false ;
13068 int val2 ;
13069 int ecode2 = 0 ;
13070 PyObject * obj0 = 0 ;
13071 PyObject * obj1 = 0 ;
13072 char * kwnames[] = {
13073 (char *) "cmd",(char *) "flags", NULL
13074 };
13075
13076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) SWIG_fail;
13077 {
13078 arg1 = wxString_in_helper(obj0);
13079 if (arg1 == NULL) SWIG_fail;
13080 temp1 = true;
13081 }
13082 if (obj1) {
13083 ecode2 = SWIG_AsVal_int(obj1, &val2);
13084 if (!SWIG_IsOK(ecode2)) {
13085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_Open" "', expected argument " "2"" of type '" "int""'");
13086 }
13087 arg2 = static_cast< int >(val2);
13088 }
13089 {
13090 PyThreadState* __tstate = wxPyBeginAllowThreads();
13091 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
13092 wxPyEndAllowThreads(__tstate);
13093 if (PyErr_Occurred()) SWIG_fail;
13094 }
13095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, 0 | 0 );
13096 {
13097 if (temp1)
13098 delete arg1;
13099 }
13100 return resultobj;
13101 fail:
13102 {
13103 if (temp1)
13104 delete arg1;
13105 }
13106 return NULL;
13107 }
13108
13109
13110 SWIGINTERN PyObject *_wrap_new_Process(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13111 PyObject *resultobj = 0;
13112 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
13113 int arg2 = (int) -1 ;
13114 wxPyProcess *result = 0 ;
13115 void *argp1 = 0 ;
13116 int res1 = 0 ;
13117 int val2 ;
13118 int ecode2 = 0 ;
13119 PyObject * obj0 = 0 ;
13120 PyObject * obj1 = 0 ;
13121 char * kwnames[] = {
13122 (char *) "parent",(char *) "id", NULL
13123 };
13124
13125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) SWIG_fail;
13126 if (obj0) {
13127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
13128 if (!SWIG_IsOK(res1)) {
13129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Process" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
13130 }
13131 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
13132 }
13133 if (obj1) {
13134 ecode2 = SWIG_AsVal_int(obj1, &val2);
13135 if (!SWIG_IsOK(ecode2)) {
13136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Process" "', expected argument " "2"" of type '" "int""'");
13137 }
13138 arg2 = static_cast< int >(val2);
13139 }
13140 {
13141 PyThreadState* __tstate = wxPyBeginAllowThreads();
13142 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
13143 wxPyEndAllowThreads(__tstate);
13144 if (PyErr_Occurred()) SWIG_fail;
13145 }
13146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyProcess, SWIG_POINTER_NEW | 0 );
13147 return resultobj;
13148 fail:
13149 return NULL;
13150 }
13151
13152
13153 SWIGINTERN PyObject *_wrap_Process__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13154 PyObject *resultobj = 0;
13155 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13156 PyObject *arg2 = (PyObject *) 0 ;
13157 PyObject *arg3 = (PyObject *) 0 ;
13158 void *argp1 = 0 ;
13159 int res1 = 0 ;
13160 PyObject * obj0 = 0 ;
13161 PyObject * obj1 = 0 ;
13162 PyObject * obj2 = 0 ;
13163 char * kwnames[] = {
13164 (char *) "self",(char *) "self",(char *) "_class", NULL
13165 };
13166
13167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13169 if (!SWIG_IsOK(res1)) {
13170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13171 }
13172 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13173 arg2 = obj1;
13174 arg3 = obj2;
13175 {
13176 PyThreadState* __tstate = wxPyBeginAllowThreads();
13177 (arg1)->_setCallbackInfo(arg2,arg3);
13178 wxPyEndAllowThreads(__tstate);
13179 if (PyErr_Occurred()) SWIG_fail;
13180 }
13181 resultobj = SWIG_Py_Void();
13182 return resultobj;
13183 fail:
13184 return NULL;
13185 }
13186
13187
13188 SWIGINTERN PyObject *_wrap_Process_OnTerminate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13189 PyObject *resultobj = 0;
13190 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13191 int arg2 ;
13192 int arg3 ;
13193 void *argp1 = 0 ;
13194 int res1 = 0 ;
13195 int val2 ;
13196 int ecode2 = 0 ;
13197 int val3 ;
13198 int ecode3 = 0 ;
13199 PyObject * obj0 = 0 ;
13200 PyObject * obj1 = 0 ;
13201 PyObject * obj2 = 0 ;
13202 char * kwnames[] = {
13203 (char *) "self",(char *) "pid",(char *) "status", NULL
13204 };
13205
13206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_OnTerminate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13208 if (!SWIG_IsOK(res1)) {
13209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_OnTerminate" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13210 }
13211 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13212 ecode2 = SWIG_AsVal_int(obj1, &val2);
13213 if (!SWIG_IsOK(ecode2)) {
13214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Process_OnTerminate" "', expected argument " "2"" of type '" "int""'");
13215 }
13216 arg2 = static_cast< int >(val2);
13217 ecode3 = SWIG_AsVal_int(obj2, &val3);
13218 if (!SWIG_IsOK(ecode3)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Process_OnTerminate" "', expected argument " "3"" of type '" "int""'");
13220 }
13221 arg3 = static_cast< int >(val3);
13222 {
13223 PyThreadState* __tstate = wxPyBeginAllowThreads();
13224 (arg1)->OnTerminate(arg2,arg3);
13225 wxPyEndAllowThreads(__tstate);
13226 if (PyErr_Occurred()) SWIG_fail;
13227 }
13228 resultobj = SWIG_Py_Void();
13229 return resultobj;
13230 fail:
13231 return NULL;
13232 }
13233
13234
13235 SWIGINTERN PyObject *_wrap_Process_Redirect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13236 PyObject *resultobj = 0;
13237 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13238 void *argp1 = 0 ;
13239 int res1 = 0 ;
13240 PyObject *swig_obj[1] ;
13241
13242 if (!args) SWIG_fail;
13243 swig_obj[0] = args;
13244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13245 if (!SWIG_IsOK(res1)) {
13246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Redirect" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13247 }
13248 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13249 {
13250 PyThreadState* __tstate = wxPyBeginAllowThreads();
13251 (arg1)->Redirect();
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 resultobj = SWIG_Py_Void();
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 SWIGINTERN PyObject *_wrap_Process_IsRedirected(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13263 PyObject *resultobj = 0;
13264 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13265 bool result;
13266 void *argp1 = 0 ;
13267 int res1 = 0 ;
13268 PyObject *swig_obj[1] ;
13269
13270 if (!args) SWIG_fail;
13271 swig_obj[0] = args;
13272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13273 if (!SWIG_IsOK(res1)) {
13274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsRedirected" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13275 }
13276 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13277 {
13278 PyThreadState* __tstate = wxPyBeginAllowThreads();
13279 result = (bool)(arg1)->IsRedirected();
13280 wxPyEndAllowThreads(__tstate);
13281 if (PyErr_Occurred()) SWIG_fail;
13282 }
13283 {
13284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13285 }
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 SWIGINTERN PyObject *_wrap_Process_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13293 PyObject *resultobj = 0;
13294 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13295 void *argp1 = 0 ;
13296 int res1 = 0 ;
13297 PyObject *swig_obj[1] ;
13298
13299 if (!args) SWIG_fail;
13300 swig_obj[0] = args;
13301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13302 if (!SWIG_IsOK(res1)) {
13303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_Detach" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13304 }
13305 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 (arg1)->Detach();
13309 wxPyEndAllowThreads(__tstate);
13310 if (PyErr_Occurred()) SWIG_fail;
13311 }
13312 resultobj = SWIG_Py_Void();
13313 return resultobj;
13314 fail:
13315 return NULL;
13316 }
13317
13318
13319 SWIGINTERN PyObject *_wrap_Process_GetInputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13320 PyObject *resultobj = 0;
13321 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13322 wxInputStream *result = 0 ;
13323 void *argp1 = 0 ;
13324 int res1 = 0 ;
13325 PyObject *swig_obj[1] ;
13326
13327 if (!args) SWIG_fail;
13328 swig_obj[0] = args;
13329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13330 if (!SWIG_IsOK(res1)) {
13331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetInputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13332 }
13333 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13334 {
13335 PyThreadState* __tstate = wxPyBeginAllowThreads();
13336 result = (wxInputStream *)(arg1)->GetInputStream();
13337 wxPyEndAllowThreads(__tstate);
13338 if (PyErr_Occurred()) SWIG_fail;
13339 }
13340 {
13341 wxPyInputStream * _ptr = NULL;
13342
13343 if (result) {
13344 _ptr = new wxPyInputStream(result);
13345 }
13346 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13347 }
13348 return resultobj;
13349 fail:
13350 return NULL;
13351 }
13352
13353
13354 SWIGINTERN PyObject *_wrap_Process_GetErrorStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13355 PyObject *resultobj = 0;
13356 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13357 wxInputStream *result = 0 ;
13358 void *argp1 = 0 ;
13359 int res1 = 0 ;
13360 PyObject *swig_obj[1] ;
13361
13362 if (!args) SWIG_fail;
13363 swig_obj[0] = args;
13364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13365 if (!SWIG_IsOK(res1)) {
13366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetErrorStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13367 }
13368 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13369 {
13370 PyThreadState* __tstate = wxPyBeginAllowThreads();
13371 result = (wxInputStream *)(arg1)->GetErrorStream();
13372 wxPyEndAllowThreads(__tstate);
13373 if (PyErr_Occurred()) SWIG_fail;
13374 }
13375 {
13376 wxPyInputStream * _ptr = NULL;
13377
13378 if (result) {
13379 _ptr = new wxPyInputStream(result);
13380 }
13381 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
13382 }
13383 return resultobj;
13384 fail:
13385 return NULL;
13386 }
13387
13388
13389 SWIGINTERN PyObject *_wrap_Process_GetOutputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13390 PyObject *resultobj = 0;
13391 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13392 wxOutputStream *result = 0 ;
13393 void *argp1 = 0 ;
13394 int res1 = 0 ;
13395 PyObject *swig_obj[1] ;
13396
13397 if (!args) SWIG_fail;
13398 swig_obj[0] = args;
13399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13400 if (!SWIG_IsOK(res1)) {
13401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_GetOutputStream" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13402 }
13403 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13404 {
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 result = (wxOutputStream *)(arg1)->GetOutputStream();
13407 wxPyEndAllowThreads(__tstate);
13408 if (PyErr_Occurred()) SWIG_fail;
13409 }
13410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxOutputStream, 0 | 0 );
13411 return resultobj;
13412 fail:
13413 return NULL;
13414 }
13415
13416
13417 SWIGINTERN PyObject *_wrap_Process_CloseOutput(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13418 PyObject *resultobj = 0;
13419 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13420 void *argp1 = 0 ;
13421 int res1 = 0 ;
13422 PyObject *swig_obj[1] ;
13423
13424 if (!args) SWIG_fail;
13425 swig_obj[0] = args;
13426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13427 if (!SWIG_IsOK(res1)) {
13428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_CloseOutput" "', expected argument " "1"" of type '" "wxPyProcess *""'");
13429 }
13430 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13431 {
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 (arg1)->CloseOutput();
13434 wxPyEndAllowThreads(__tstate);
13435 if (PyErr_Occurred()) SWIG_fail;
13436 }
13437 resultobj = SWIG_Py_Void();
13438 return resultobj;
13439 fail:
13440 return NULL;
13441 }
13442
13443
13444 SWIGINTERN PyObject *_wrap_Process_IsInputOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13445 PyObject *resultobj = 0;
13446 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13447 bool result;
13448 void *argp1 = 0 ;
13449 int res1 = 0 ;
13450 PyObject *swig_obj[1] ;
13451
13452 if (!args) SWIG_fail;
13453 swig_obj[0] = args;
13454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13455 if (!SWIG_IsOK(res1)) {
13456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputOpened" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13457 }
13458 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13459 {
13460 PyThreadState* __tstate = wxPyBeginAllowThreads();
13461 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
13462 wxPyEndAllowThreads(__tstate);
13463 if (PyErr_Occurred()) SWIG_fail;
13464 }
13465 {
13466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13467 }
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 SWIGINTERN PyObject *_wrap_Process_IsInputAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13475 PyObject *resultobj = 0;
13476 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13477 bool result;
13478 void *argp1 = 0 ;
13479 int res1 = 0 ;
13480 PyObject *swig_obj[1] ;
13481
13482 if (!args) SWIG_fail;
13483 swig_obj[0] = args;
13484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13485 if (!SWIG_IsOK(res1)) {
13486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsInputAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13487 }
13488 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13489 {
13490 PyThreadState* __tstate = wxPyBeginAllowThreads();
13491 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 {
13496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13497 }
13498 return resultobj;
13499 fail:
13500 return NULL;
13501 }
13502
13503
13504 SWIGINTERN PyObject *_wrap_Process_IsErrorAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13505 PyObject *resultobj = 0;
13506 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
13507 bool result;
13508 void *argp1 = 0 ;
13509 int res1 = 0 ;
13510 PyObject *swig_obj[1] ;
13511
13512 if (!args) SWIG_fail;
13513 swig_obj[0] = args;
13514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13515 if (!SWIG_IsOK(res1)) {
13516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Process_IsErrorAvailable" "', expected argument " "1"" of type '" "wxPyProcess const *""'");
13517 }
13518 arg1 = reinterpret_cast< wxPyProcess * >(argp1);
13519 {
13520 PyThreadState* __tstate = wxPyBeginAllowThreads();
13521 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 {
13526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13527 }
13528 return resultobj;
13529 fail:
13530 return NULL;
13531 }
13532
13533
13534 SWIGINTERN PyObject *Process_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13535 PyObject *obj;
13536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13537 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyProcess, SWIG_NewClientData(obj));
13538 return SWIG_Py_Void();
13539 }
13540
13541 SWIGINTERN PyObject *Process_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13542 return SWIG_Python_InitShadowInstance(args);
13543 }
13544
13545 SWIGINTERN PyObject *_wrap_new_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj = 0;
13547 int arg1 = (int) 0 ;
13548 int arg2 = (int) 0 ;
13549 int arg3 = (int) 0 ;
13550 wxProcessEvent *result = 0 ;
13551 int val1 ;
13552 int ecode1 = 0 ;
13553 int val2 ;
13554 int ecode2 = 0 ;
13555 int val3 ;
13556 int ecode3 = 0 ;
13557 PyObject * obj0 = 0 ;
13558 PyObject * obj1 = 0 ;
13559 PyObject * obj2 = 0 ;
13560 char * kwnames[] = {
13561 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
13562 };
13563
13564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13565 if (obj0) {
13566 ecode1 = SWIG_AsVal_int(obj0, &val1);
13567 if (!SWIG_IsOK(ecode1)) {
13568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ProcessEvent" "', expected argument " "1"" of type '" "int""'");
13569 }
13570 arg1 = static_cast< int >(val1);
13571 }
13572 if (obj1) {
13573 ecode2 = SWIG_AsVal_int(obj1, &val2);
13574 if (!SWIG_IsOK(ecode2)) {
13575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ProcessEvent" "', expected argument " "2"" of type '" "int""'");
13576 }
13577 arg2 = static_cast< int >(val2);
13578 }
13579 if (obj2) {
13580 ecode3 = SWIG_AsVal_int(obj2, &val3);
13581 if (!SWIG_IsOK(ecode3)) {
13582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProcessEvent" "', expected argument " "3"" of type '" "int""'");
13583 }
13584 arg3 = static_cast< int >(val3);
13585 }
13586 {
13587 PyThreadState* __tstate = wxPyBeginAllowThreads();
13588 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_NEW | 0 );
13593 return resultobj;
13594 fail:
13595 return NULL;
13596 }
13597
13598
13599 SWIGINTERN PyObject *_wrap_ProcessEvent_GetPid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13600 PyObject *resultobj = 0;
13601 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13602 int result;
13603 void *argp1 = 0 ;
13604 int res1 = 0 ;
13605 PyObject *swig_obj[1] ;
13606
13607 if (!args) SWIG_fail;
13608 swig_obj[0] = args;
13609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13610 if (!SWIG_IsOK(res1)) {
13611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetPid" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13612 }
13613 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13614 {
13615 PyThreadState* __tstate = wxPyBeginAllowThreads();
13616 result = (int)(arg1)->GetPid();
13617 wxPyEndAllowThreads(__tstate);
13618 if (PyErr_Occurred()) SWIG_fail;
13619 }
13620 resultobj = SWIG_From_int(static_cast< int >(result));
13621 return resultobj;
13622 fail:
13623 return NULL;
13624 }
13625
13626
13627 SWIGINTERN PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13628 PyObject *resultobj = 0;
13629 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13630 int result;
13631 void *argp1 = 0 ;
13632 int res1 = 0 ;
13633 PyObject *swig_obj[1] ;
13634
13635 if (!args) SWIG_fail;
13636 swig_obj[0] = args;
13637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13638 if (!SWIG_IsOK(res1)) {
13639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_GetExitCode" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13640 }
13641 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13642 {
13643 PyThreadState* __tstate = wxPyBeginAllowThreads();
13644 result = (int)(arg1)->GetExitCode();
13645 wxPyEndAllowThreads(__tstate);
13646 if (PyErr_Occurred()) SWIG_fail;
13647 }
13648 resultobj = SWIG_From_int(static_cast< int >(result));
13649 return resultobj;
13650 fail:
13651 return NULL;
13652 }
13653
13654
13655 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13656 PyObject *resultobj = 0;
13657 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13658 int arg2 ;
13659 void *argp1 = 0 ;
13660 int res1 = 0 ;
13661 int val2 ;
13662 int ecode2 = 0 ;
13663 PyObject *swig_obj[2] ;
13664
13665 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_pid_set",2,2,swig_obj)) SWIG_fail;
13666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13667 if (!SWIG_IsOK(res1)) {
13668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13669 }
13670 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13671 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13672 if (!SWIG_IsOK(ecode2)) {
13673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_pid_set" "', expected argument " "2"" of type '" "int""'");
13674 }
13675 arg2 = static_cast< int >(val2);
13676 if (arg1) (arg1)->m_pid = arg2;
13677
13678 resultobj = SWIG_Py_Void();
13679 return resultobj;
13680 fail:
13681 return NULL;
13682 }
13683
13684
13685 SWIGINTERN PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13686 PyObject *resultobj = 0;
13687 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13688 int result;
13689 void *argp1 = 0 ;
13690 int res1 = 0 ;
13691 PyObject *swig_obj[1] ;
13692
13693 if (!args) SWIG_fail;
13694 swig_obj[0] = args;
13695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13696 if (!SWIG_IsOK(res1)) {
13697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_pid_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13698 }
13699 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13700 result = (int) ((arg1)->m_pid);
13701 resultobj = SWIG_From_int(static_cast< int >(result));
13702 return resultobj;
13703 fail:
13704 return NULL;
13705 }
13706
13707
13708 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13709 PyObject *resultobj = 0;
13710 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13711 int arg2 ;
13712 void *argp1 = 0 ;
13713 int res1 = 0 ;
13714 int val2 ;
13715 int ecode2 = 0 ;
13716 PyObject *swig_obj[2] ;
13717
13718 if (!SWIG_Python_UnpackTuple(args,"ProcessEvent_m_exitcode_set",2,2,swig_obj)) SWIG_fail;
13719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13720 if (!SWIG_IsOK(res1)) {
13721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13722 }
13723 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13724 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
13725 if (!SWIG_IsOK(ecode2)) {
13726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ProcessEvent_m_exitcode_set" "', expected argument " "2"" of type '" "int""'");
13727 }
13728 arg2 = static_cast< int >(val2);
13729 if (arg1) (arg1)->m_exitcode = arg2;
13730
13731 resultobj = SWIG_Py_Void();
13732 return resultobj;
13733 fail:
13734 return NULL;
13735 }
13736
13737
13738 SWIGINTERN PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13739 PyObject *resultobj = 0;
13740 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
13741 int result;
13742 void *argp1 = 0 ;
13743 int res1 = 0 ;
13744 PyObject *swig_obj[1] ;
13745
13746 if (!args) SWIG_fail;
13747 swig_obj[0] = args;
13748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxProcessEvent, 0 | 0 );
13749 if (!SWIG_IsOK(res1)) {
13750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProcessEvent_m_exitcode_get" "', expected argument " "1"" of type '" "wxProcessEvent *""'");
13751 }
13752 arg1 = reinterpret_cast< wxProcessEvent * >(argp1);
13753 result = (int) ((arg1)->m_exitcode);
13754 resultobj = SWIG_From_int(static_cast< int >(result));
13755 return resultobj;
13756 fail:
13757 return NULL;
13758 }
13759
13760
13761 SWIGINTERN PyObject *ProcessEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13762 PyObject *obj;
13763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13764 SWIG_TypeNewClientData(SWIGTYPE_p_wxProcessEvent, SWIG_NewClientData(obj));
13765 return SWIG_Py_Void();
13766 }
13767
13768 SWIGINTERN PyObject *ProcessEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13769 return SWIG_Python_InitShadowInstance(args);
13770 }
13771
13772 SWIGINTERN PyObject *_wrap_Execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13773 PyObject *resultobj = 0;
13774 wxString *arg1 = 0 ;
13775 int arg2 = (int) wxEXEC_ASYNC ;
13776 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
13777 long result;
13778 bool temp1 = false ;
13779 int val2 ;
13780 int ecode2 = 0 ;
13781 void *argp3 = 0 ;
13782 int res3 = 0 ;
13783 PyObject * obj0 = 0 ;
13784 PyObject * obj1 = 0 ;
13785 PyObject * obj2 = 0 ;
13786 char * kwnames[] = {
13787 (char *) "command",(char *) "flags",(char *) "process", NULL
13788 };
13789
13790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13791 {
13792 arg1 = wxString_in_helper(obj0);
13793 if (arg1 == NULL) SWIG_fail;
13794 temp1 = true;
13795 }
13796 if (obj1) {
13797 ecode2 = SWIG_AsVal_int(obj1, &val2);
13798 if (!SWIG_IsOK(ecode2)) {
13799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Execute" "', expected argument " "2"" of type '" "int""'");
13800 }
13801 arg2 = static_cast< int >(val2);
13802 }
13803 if (obj2) {
13804 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxPyProcess, 0 | 0 );
13805 if (!SWIG_IsOK(res3)) {
13806 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Execute" "', expected argument " "3"" of type '" "wxPyProcess *""'");
13807 }
13808 arg3 = reinterpret_cast< wxPyProcess * >(argp3);
13809 }
13810 {
13811 if (!wxPyCheckForApp()) SWIG_fail;
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
13814 wxPyEndAllowThreads(__tstate);
13815 if (PyErr_Occurred()) SWIG_fail;
13816 }
13817 resultobj = SWIG_From_long(static_cast< long >(result));
13818 {
13819 if (temp1)
13820 delete arg1;
13821 }
13822 return resultobj;
13823 fail:
13824 {
13825 if (temp1)
13826 delete arg1;
13827 }
13828 return NULL;
13829 }
13830
13831
13832 SWIGINTERN PyObject *_wrap_Kill(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13833 PyObject *resultobj = 0;
13834 long arg1 ;
13835 wxSignal arg2 = (wxSignal) wxSIGTERM ;
13836 wxKillError *arg3 = (wxKillError *) 0 ;
13837 int arg4 = (int) wxKILL_NOCHILDREN ;
13838 int result;
13839 long val1 ;
13840 int ecode1 = 0 ;
13841 int val2 ;
13842 int ecode2 = 0 ;
13843 wxKillError temp3 ;
13844 int val4 ;
13845 int ecode4 = 0 ;
13846 PyObject * obj0 = 0 ;
13847 PyObject * obj1 = 0 ;
13848 PyObject * obj2 = 0 ;
13849 char * kwnames[] = {
13850 (char *) "pid",(char *) "sig",(char *) "flags", NULL
13851 };
13852
13853 {
13854 arg3 = &temp3;
13855 }
13856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13857 ecode1 = SWIG_AsVal_long(obj0, &val1);
13858 if (!SWIG_IsOK(ecode1)) {
13859 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Kill" "', expected argument " "1"" of type '" "long""'");
13860 }
13861 arg1 = static_cast< long >(val1);
13862 if (obj1) {
13863 ecode2 = SWIG_AsVal_int(obj1, &val2);
13864 if (!SWIG_IsOK(ecode2)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Kill" "', expected argument " "2"" of type '" "wxSignal""'");
13866 }
13867 arg2 = static_cast< wxSignal >(val2);
13868 }
13869 if (obj2) {
13870 ecode4 = SWIG_AsVal_int(obj2, &val4);
13871 if (!SWIG_IsOK(ecode4)) {
13872 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Kill" "', expected argument " "4"" of type '" "int""'");
13873 }
13874 arg4 = static_cast< int >(val4);
13875 }
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 result = (int)wxKill(arg1,arg2,arg3,arg4);
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_From_int(static_cast< int >(result));
13883 {
13884 PyObject* o;
13885 o = PyInt_FromLong((long) (*arg3));
13886
13887
13888
13889 resultobj = SWIG_Python_AppendOutput(resultobj, o);
13890
13891 }
13892 return resultobj;
13893 fail:
13894 return NULL;
13895 }
13896
13897
13898 SWIGINTERN PyObject *_wrap_new_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13899 PyObject *resultobj = 0;
13900 int arg1 = (int) wxJOYSTICK1 ;
13901 wxJoystick *result = 0 ;
13902 int val1 ;
13903 int ecode1 = 0 ;
13904 PyObject * obj0 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "joystick", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) SWIG_fail;
13910 if (obj0) {
13911 ecode1 = SWIG_AsVal_int(obj0, &val1);
13912 if (!SWIG_IsOK(ecode1)) {
13913 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Joystick" "', expected argument " "1"" of type '" "int""'");
13914 }
13915 arg1 = static_cast< int >(val1);
13916 }
13917 {
13918 if (!wxPyCheckForApp()) SWIG_fail;
13919 PyThreadState* __tstate = wxPyBeginAllowThreads();
13920 result = (wxJoystick *)new wxJoystick(arg1);
13921 wxPyEndAllowThreads(__tstate);
13922 if (PyErr_Occurred()) SWIG_fail;
13923 }
13924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystick, SWIG_POINTER_NEW | 0 );
13925 return resultobj;
13926 fail:
13927 return NULL;
13928 }
13929
13930
13931 SWIGINTERN PyObject *_wrap_delete_Joystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13932 PyObject *resultobj = 0;
13933 wxJoystick *arg1 = (wxJoystick *) 0 ;
13934 void *argp1 = 0 ;
13935 int res1 = 0 ;
13936 PyObject *swig_obj[1] ;
13937
13938 if (!args) SWIG_fail;
13939 swig_obj[0] = args;
13940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, SWIG_POINTER_DISOWN | 0 );
13941 if (!SWIG_IsOK(res1)) {
13942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Joystick" "', expected argument " "1"" of type '" "wxJoystick *""'");
13943 }
13944 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 delete arg1;
13948
13949 wxPyEndAllowThreads(__tstate);
13950 if (PyErr_Occurred()) SWIG_fail;
13951 }
13952 resultobj = SWIG_Py_Void();
13953 return resultobj;
13954 fail:
13955 return NULL;
13956 }
13957
13958
13959 SWIGINTERN PyObject *_wrap_Joystick_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13960 PyObject *resultobj = 0;
13961 wxJoystick *arg1 = (wxJoystick *) 0 ;
13962 wxPoint result;
13963 void *argp1 = 0 ;
13964 int res1 = 0 ;
13965 PyObject *swig_obj[1] ;
13966
13967 if (!args) SWIG_fail;
13968 swig_obj[0] = args;
13969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13970 if (!SWIG_IsOK(res1)) {
13971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
13972 }
13973 arg1 = reinterpret_cast< wxJoystick * >(argp1);
13974 {
13975 PyThreadState* __tstate = wxPyBeginAllowThreads();
13976 result = (arg1)->GetPosition();
13977 wxPyEndAllowThreads(__tstate);
13978 if (PyErr_Occurred()) SWIG_fail;
13979 }
13980 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
13981 return resultobj;
13982 fail:
13983 return NULL;
13984 }
13985
13986
13987 SWIGINTERN PyObject *_wrap_Joystick_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13988 PyObject *resultobj = 0;
13989 wxJoystick *arg1 = (wxJoystick *) 0 ;
13990 int result;
13991 void *argp1 = 0 ;
13992 int res1 = 0 ;
13993 PyObject *swig_obj[1] ;
13994
13995 if (!args) SWIG_fail;
13996 swig_obj[0] = args;
13997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
13998 if (!SWIG_IsOK(res1)) {
13999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14000 }
14001 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14002 {
14003 PyThreadState* __tstate = wxPyBeginAllowThreads();
14004 result = (int)(arg1)->GetZPosition();
14005 wxPyEndAllowThreads(__tstate);
14006 if (PyErr_Occurred()) SWIG_fail;
14007 }
14008 resultobj = SWIG_From_int(static_cast< int >(result));
14009 return resultobj;
14010 fail:
14011 return NULL;
14012 }
14013
14014
14015 SWIGINTERN PyObject *_wrap_Joystick_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14016 PyObject *resultobj = 0;
14017 wxJoystick *arg1 = (wxJoystick *) 0 ;
14018 int result;
14019 void *argp1 = 0 ;
14020 int res1 = 0 ;
14021 PyObject *swig_obj[1] ;
14022
14023 if (!args) SWIG_fail;
14024 swig_obj[0] = args;
14025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14026 if (!SWIG_IsOK(res1)) {
14027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetButtonState" "', expected argument " "1"" of type '" "wxJoystick *""'");
14028 }
14029 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14030 {
14031 PyThreadState* __tstate = wxPyBeginAllowThreads();
14032 result = (int)(arg1)->GetButtonState();
14033 wxPyEndAllowThreads(__tstate);
14034 if (PyErr_Occurred()) SWIG_fail;
14035 }
14036 resultobj = SWIG_From_int(static_cast< int >(result));
14037 return resultobj;
14038 fail:
14039 return NULL;
14040 }
14041
14042
14043 SWIGINTERN PyObject *_wrap_Joystick_GetPOVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14044 PyObject *resultobj = 0;
14045 wxJoystick *arg1 = (wxJoystick *) 0 ;
14046 int result;
14047 void *argp1 = 0 ;
14048 int res1 = 0 ;
14049 PyObject *swig_obj[1] ;
14050
14051 if (!args) SWIG_fail;
14052 swig_obj[0] = args;
14053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14054 if (!SWIG_IsOK(res1)) {
14055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14056 }
14057 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14058 {
14059 PyThreadState* __tstate = wxPyBeginAllowThreads();
14060 result = (int)(arg1)->GetPOVPosition();
14061 wxPyEndAllowThreads(__tstate);
14062 if (PyErr_Occurred()) SWIG_fail;
14063 }
14064 resultobj = SWIG_From_int(static_cast< int >(result));
14065 return resultobj;
14066 fail:
14067 return NULL;
14068 }
14069
14070
14071 SWIGINTERN PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14072 PyObject *resultobj = 0;
14073 wxJoystick *arg1 = (wxJoystick *) 0 ;
14074 int result;
14075 void *argp1 = 0 ;
14076 int res1 = 0 ;
14077 PyObject *swig_obj[1] ;
14078
14079 if (!args) SWIG_fail;
14080 swig_obj[0] = args;
14081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14082 if (!SWIG_IsOK(res1)) {
14083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPOVCTSPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14084 }
14085 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14086 {
14087 PyThreadState* __tstate = wxPyBeginAllowThreads();
14088 result = (int)(arg1)->GetPOVCTSPosition();
14089 wxPyEndAllowThreads(__tstate);
14090 if (PyErr_Occurred()) SWIG_fail;
14091 }
14092 resultobj = SWIG_From_int(static_cast< int >(result));
14093 return resultobj;
14094 fail:
14095 return NULL;
14096 }
14097
14098
14099 SWIGINTERN PyObject *_wrap_Joystick_GetRudderPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14100 PyObject *resultobj = 0;
14101 wxJoystick *arg1 = (wxJoystick *) 0 ;
14102 int result;
14103 void *argp1 = 0 ;
14104 int res1 = 0 ;
14105 PyObject *swig_obj[1] ;
14106
14107 if (!args) SWIG_fail;
14108 swig_obj[0] = args;
14109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14112 }
14113 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 result = (int)(arg1)->GetRudderPosition();
14117 wxPyEndAllowThreads(__tstate);
14118 if (PyErr_Occurred()) SWIG_fail;
14119 }
14120 resultobj = SWIG_From_int(static_cast< int >(result));
14121 return resultobj;
14122 fail:
14123 return NULL;
14124 }
14125
14126
14127 SWIGINTERN PyObject *_wrap_Joystick_GetUPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14128 PyObject *resultobj = 0;
14129 wxJoystick *arg1 = (wxJoystick *) 0 ;
14130 int result;
14131 void *argp1 = 0 ;
14132 int res1 = 0 ;
14133 PyObject *swig_obj[1] ;
14134
14135 if (!args) SWIG_fail;
14136 swig_obj[0] = args;
14137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14138 if (!SWIG_IsOK(res1)) {
14139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14140 }
14141 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14142 {
14143 PyThreadState* __tstate = wxPyBeginAllowThreads();
14144 result = (int)(arg1)->GetUPosition();
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 resultobj = SWIG_From_int(static_cast< int >(result));
14149 return resultobj;
14150 fail:
14151 return NULL;
14152 }
14153
14154
14155 SWIGINTERN PyObject *_wrap_Joystick_GetVPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14156 PyObject *resultobj = 0;
14157 wxJoystick *arg1 = (wxJoystick *) 0 ;
14158 int result;
14159 void *argp1 = 0 ;
14160 int res1 = 0 ;
14161 PyObject *swig_obj[1] ;
14162
14163 if (!args) SWIG_fail;
14164 swig_obj[0] = args;
14165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14166 if (!SWIG_IsOK(res1)) {
14167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVPosition" "', expected argument " "1"" of type '" "wxJoystick *""'");
14168 }
14169 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 result = (int)(arg1)->GetVPosition();
14173 wxPyEndAllowThreads(__tstate);
14174 if (PyErr_Occurred()) SWIG_fail;
14175 }
14176 resultobj = SWIG_From_int(static_cast< int >(result));
14177 return resultobj;
14178 fail:
14179 return NULL;
14180 }
14181
14182
14183 SWIGINTERN PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14184 PyObject *resultobj = 0;
14185 wxJoystick *arg1 = (wxJoystick *) 0 ;
14186 int result;
14187 void *argp1 = 0 ;
14188 int res1 = 0 ;
14189 PyObject *swig_obj[1] ;
14190
14191 if (!args) SWIG_fail;
14192 swig_obj[0] = args;
14193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14194 if (!SWIG_IsOK(res1)) {
14195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14196 }
14197 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14198 {
14199 PyThreadState* __tstate = wxPyBeginAllowThreads();
14200 result = (int)(arg1)->GetMovementThreshold();
14201 wxPyEndAllowThreads(__tstate);
14202 if (PyErr_Occurred()) SWIG_fail;
14203 }
14204 resultobj = SWIG_From_int(static_cast< int >(result));
14205 return resultobj;
14206 fail:
14207 return NULL;
14208 }
14209
14210
14211 SWIGINTERN PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14212 PyObject *resultobj = 0;
14213 wxJoystick *arg1 = (wxJoystick *) 0 ;
14214 int arg2 ;
14215 void *argp1 = 0 ;
14216 int res1 = 0 ;
14217 int val2 ;
14218 int ecode2 = 0 ;
14219 PyObject * obj0 = 0 ;
14220 PyObject * obj1 = 0 ;
14221 char * kwnames[] = {
14222 (char *) "self",(char *) "threshold", NULL
14223 };
14224
14225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) SWIG_fail;
14226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14227 if (!SWIG_IsOK(res1)) {
14228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "1"" of type '" "wxJoystick *""'");
14229 }
14230 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14231 ecode2 = SWIG_AsVal_int(obj1, &val2);
14232 if (!SWIG_IsOK(ecode2)) {
14233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Joystick_SetMovementThreshold" "', expected argument " "2"" of type '" "int""'");
14234 }
14235 arg2 = static_cast< int >(val2);
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 (arg1)->SetMovementThreshold(arg2);
14239 wxPyEndAllowThreads(__tstate);
14240 if (PyErr_Occurred()) SWIG_fail;
14241 }
14242 resultobj = SWIG_Py_Void();
14243 return resultobj;
14244 fail:
14245 return NULL;
14246 }
14247
14248
14249 SWIGINTERN PyObject *_wrap_Joystick_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14250 PyObject *resultobj = 0;
14251 wxJoystick *arg1 = (wxJoystick *) 0 ;
14252 bool result;
14253 void *argp1 = 0 ;
14254 int res1 = 0 ;
14255 PyObject *swig_obj[1] ;
14256
14257 if (!args) SWIG_fail;
14258 swig_obj[0] = args;
14259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14260 if (!SWIG_IsOK(res1)) {
14261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_IsOk" "', expected argument " "1"" of type '" "wxJoystick *""'");
14262 }
14263 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14264 {
14265 PyThreadState* __tstate = wxPyBeginAllowThreads();
14266 result = (bool)(arg1)->IsOk();
14267 wxPyEndAllowThreads(__tstate);
14268 if (PyErr_Occurred()) SWIG_fail;
14269 }
14270 {
14271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14272 }
14273 return resultobj;
14274 fail:
14275 return NULL;
14276 }
14277
14278
14279 SWIGINTERN PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14280 PyObject *resultobj = 0;
14281 wxJoystick *arg1 = (wxJoystick *) 0 ;
14282 int result;
14283 void *argp1 = 0 ;
14284 int res1 = 0 ;
14285 PyObject *swig_obj[1] ;
14286
14287 if (!args) SWIG_fail;
14288 swig_obj[0] = args;
14289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14290 if (!SWIG_IsOK(res1)) {
14291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberJoysticks" "', expected argument " "1"" of type '" "wxJoystick *""'");
14292 }
14293 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14294 {
14295 PyThreadState* __tstate = wxPyBeginAllowThreads();
14296 result = (int)(arg1)->GetNumberJoysticks();
14297 wxPyEndAllowThreads(__tstate);
14298 if (PyErr_Occurred()) SWIG_fail;
14299 }
14300 resultobj = SWIG_From_int(static_cast< int >(result));
14301 return resultobj;
14302 fail:
14303 return NULL;
14304 }
14305
14306
14307 SWIGINTERN PyObject *_wrap_Joystick_GetManufacturerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14308 PyObject *resultobj = 0;
14309 wxJoystick *arg1 = (wxJoystick *) 0 ;
14310 int result;
14311 void *argp1 = 0 ;
14312 int res1 = 0 ;
14313 PyObject *swig_obj[1] ;
14314
14315 if (!args) SWIG_fail;
14316 swig_obj[0] = args;
14317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14318 if (!SWIG_IsOK(res1)) {
14319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetManufacturerId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14320 }
14321 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14322 {
14323 PyThreadState* __tstate = wxPyBeginAllowThreads();
14324 result = (int)(arg1)->GetManufacturerId();
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 resultobj = SWIG_From_int(static_cast< int >(result));
14329 return resultobj;
14330 fail:
14331 return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_Joystick_GetProductId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14336 PyObject *resultobj = 0;
14337 wxJoystick *arg1 = (wxJoystick *) 0 ;
14338 int result;
14339 void *argp1 = 0 ;
14340 int res1 = 0 ;
14341 PyObject *swig_obj[1] ;
14342
14343 if (!args) SWIG_fail;
14344 swig_obj[0] = args;
14345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14346 if (!SWIG_IsOK(res1)) {
14347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductId" "', expected argument " "1"" of type '" "wxJoystick *""'");
14348 }
14349 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14350 {
14351 PyThreadState* __tstate = wxPyBeginAllowThreads();
14352 result = (int)(arg1)->GetProductId();
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 resultobj = SWIG_From_int(static_cast< int >(result));
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 SWIGINTERN PyObject *_wrap_Joystick_GetProductName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14364 PyObject *resultobj = 0;
14365 wxJoystick *arg1 = (wxJoystick *) 0 ;
14366 wxString result;
14367 void *argp1 = 0 ;
14368 int res1 = 0 ;
14369 PyObject *swig_obj[1] ;
14370
14371 if (!args) SWIG_fail;
14372 swig_obj[0] = args;
14373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14374 if (!SWIG_IsOK(res1)) {
14375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetProductName" "', expected argument " "1"" of type '" "wxJoystick *""'");
14376 }
14377 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (arg1)->GetProductName();
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 #if wxUSE_UNICODE
14386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14387 #else
14388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14389 #endif
14390 }
14391 return resultobj;
14392 fail:
14393 return NULL;
14394 }
14395
14396
14397 SWIGINTERN PyObject *_wrap_Joystick_GetXMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14398 PyObject *resultobj = 0;
14399 wxJoystick *arg1 = (wxJoystick *) 0 ;
14400 int result;
14401 void *argp1 = 0 ;
14402 int res1 = 0 ;
14403 PyObject *swig_obj[1] ;
14404
14405 if (!args) SWIG_fail;
14406 swig_obj[0] = args;
14407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14408 if (!SWIG_IsOK(res1)) {
14409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14410 }
14411 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (int)(arg1)->GetXMin();
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 resultobj = SWIG_From_int(static_cast< int >(result));
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 SWIGINTERN PyObject *_wrap_Joystick_GetYMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14426 PyObject *resultobj = 0;
14427 wxJoystick *arg1 = (wxJoystick *) 0 ;
14428 int result;
14429 void *argp1 = 0 ;
14430 int res1 = 0 ;
14431 PyObject *swig_obj[1] ;
14432
14433 if (!args) SWIG_fail;
14434 swig_obj[0] = args;
14435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14436 if (!SWIG_IsOK(res1)) {
14437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14438 }
14439 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 result = (int)(arg1)->GetYMin();
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 resultobj = SWIG_From_int(static_cast< int >(result));
14447 return resultobj;
14448 fail:
14449 return NULL;
14450 }
14451
14452
14453 SWIGINTERN PyObject *_wrap_Joystick_GetZMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14454 PyObject *resultobj = 0;
14455 wxJoystick *arg1 = (wxJoystick *) 0 ;
14456 int 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_GetZMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14466 }
14467 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 result = (int)(arg1)->GetZMin();
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 resultobj = SWIG_From_int(static_cast< int >(result));
14475 return resultobj;
14476 fail:
14477 return NULL;
14478 }
14479
14480
14481 SWIGINTERN PyObject *_wrap_Joystick_GetXMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14482 PyObject *resultobj = 0;
14483 wxJoystick *arg1 = (wxJoystick *) 0 ;
14484 int result;
14485 void *argp1 = 0 ;
14486 int res1 = 0 ;
14487 PyObject *swig_obj[1] ;
14488
14489 if (!args) SWIG_fail;
14490 swig_obj[0] = args;
14491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14492 if (!SWIG_IsOK(res1)) {
14493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetXMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14494 }
14495 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14496 {
14497 PyThreadState* __tstate = wxPyBeginAllowThreads();
14498 result = (int)(arg1)->GetXMax();
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 resultobj = SWIG_From_int(static_cast< int >(result));
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 SWIGINTERN PyObject *_wrap_Joystick_GetYMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14510 PyObject *resultobj = 0;
14511 wxJoystick *arg1 = (wxJoystick *) 0 ;
14512 int result;
14513 void *argp1 = 0 ;
14514 int res1 = 0 ;
14515 PyObject *swig_obj[1] ;
14516
14517 if (!args) SWIG_fail;
14518 swig_obj[0] = args;
14519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14520 if (!SWIG_IsOK(res1)) {
14521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetYMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14522 }
14523 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14524 {
14525 PyThreadState* __tstate = wxPyBeginAllowThreads();
14526 result = (int)(arg1)->GetYMax();
14527 wxPyEndAllowThreads(__tstate);
14528 if (PyErr_Occurred()) SWIG_fail;
14529 }
14530 resultobj = SWIG_From_int(static_cast< int >(result));
14531 return resultobj;
14532 fail:
14533 return NULL;
14534 }
14535
14536
14537 SWIGINTERN PyObject *_wrap_Joystick_GetZMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14538 PyObject *resultobj = 0;
14539 wxJoystick *arg1 = (wxJoystick *) 0 ;
14540 int result;
14541 void *argp1 = 0 ;
14542 int res1 = 0 ;
14543 PyObject *swig_obj[1] ;
14544
14545 if (!args) SWIG_fail;
14546 swig_obj[0] = args;
14547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14548 if (!SWIG_IsOK(res1)) {
14549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetZMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14550 }
14551 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14552 {
14553 PyThreadState* __tstate = wxPyBeginAllowThreads();
14554 result = (int)(arg1)->GetZMax();
14555 wxPyEndAllowThreads(__tstate);
14556 if (PyErr_Occurred()) SWIG_fail;
14557 }
14558 resultobj = SWIG_From_int(static_cast< int >(result));
14559 return resultobj;
14560 fail:
14561 return NULL;
14562 }
14563
14564
14565 SWIGINTERN PyObject *_wrap_Joystick_GetNumberButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14566 PyObject *resultobj = 0;
14567 wxJoystick *arg1 = (wxJoystick *) 0 ;
14568 int result;
14569 void *argp1 = 0 ;
14570 int res1 = 0 ;
14571 PyObject *swig_obj[1] ;
14572
14573 if (!args) SWIG_fail;
14574 swig_obj[0] = args;
14575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14576 if (!SWIG_IsOK(res1)) {
14577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14578 }
14579 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14580 {
14581 PyThreadState* __tstate = wxPyBeginAllowThreads();
14582 result = (int)(arg1)->GetNumberButtons();
14583 wxPyEndAllowThreads(__tstate);
14584 if (PyErr_Occurred()) SWIG_fail;
14585 }
14586 resultobj = SWIG_From_int(static_cast< int >(result));
14587 return resultobj;
14588 fail:
14589 return NULL;
14590 }
14591
14592
14593 SWIGINTERN PyObject *_wrap_Joystick_GetNumberAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14594 PyObject *resultobj = 0;
14595 wxJoystick *arg1 = (wxJoystick *) 0 ;
14596 int result;
14597 void *argp1 = 0 ;
14598 int res1 = 0 ;
14599 PyObject *swig_obj[1] ;
14600
14601 if (!args) SWIG_fail;
14602 swig_obj[0] = args;
14603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14604 if (!SWIG_IsOK(res1)) {
14605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetNumberAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14606 }
14607 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14608 {
14609 PyThreadState* __tstate = wxPyBeginAllowThreads();
14610 result = (int)(arg1)->GetNumberAxes();
14611 wxPyEndAllowThreads(__tstate);
14612 if (PyErr_Occurred()) SWIG_fail;
14613 }
14614 resultobj = SWIG_From_int(static_cast< int >(result));
14615 return resultobj;
14616 fail:
14617 return NULL;
14618 }
14619
14620
14621 SWIGINTERN PyObject *_wrap_Joystick_GetMaxButtons(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14622 PyObject *resultobj = 0;
14623 wxJoystick *arg1 = (wxJoystick *) 0 ;
14624 int result;
14625 void *argp1 = 0 ;
14626 int res1 = 0 ;
14627 PyObject *swig_obj[1] ;
14628
14629 if (!args) SWIG_fail;
14630 swig_obj[0] = args;
14631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14632 if (!SWIG_IsOK(res1)) {
14633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxButtons" "', expected argument " "1"" of type '" "wxJoystick *""'");
14634 }
14635 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14636 {
14637 PyThreadState* __tstate = wxPyBeginAllowThreads();
14638 result = (int)(arg1)->GetMaxButtons();
14639 wxPyEndAllowThreads(__tstate);
14640 if (PyErr_Occurred()) SWIG_fail;
14641 }
14642 resultobj = SWIG_From_int(static_cast< int >(result));
14643 return resultobj;
14644 fail:
14645 return NULL;
14646 }
14647
14648
14649 SWIGINTERN PyObject *_wrap_Joystick_GetMaxAxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14650 PyObject *resultobj = 0;
14651 wxJoystick *arg1 = (wxJoystick *) 0 ;
14652 int result;
14653 void *argp1 = 0 ;
14654 int res1 = 0 ;
14655 PyObject *swig_obj[1] ;
14656
14657 if (!args) SWIG_fail;
14658 swig_obj[0] = args;
14659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14660 if (!SWIG_IsOK(res1)) {
14661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetMaxAxes" "', expected argument " "1"" of type '" "wxJoystick *""'");
14662 }
14663 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14664 {
14665 PyThreadState* __tstate = wxPyBeginAllowThreads();
14666 result = (int)(arg1)->GetMaxAxes();
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 resultobj = SWIG_From_int(static_cast< int >(result));
14671 return resultobj;
14672 fail:
14673 return NULL;
14674 }
14675
14676
14677 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14678 PyObject *resultobj = 0;
14679 wxJoystick *arg1 = (wxJoystick *) 0 ;
14680 int result;
14681 void *argp1 = 0 ;
14682 int res1 = 0 ;
14683 PyObject *swig_obj[1] ;
14684
14685 if (!args) SWIG_fail;
14686 swig_obj[0] = args;
14687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14690 }
14691 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14692 {
14693 PyThreadState* __tstate = wxPyBeginAllowThreads();
14694 result = (int)(arg1)->GetPollingMin();
14695 wxPyEndAllowThreads(__tstate);
14696 if (PyErr_Occurred()) SWIG_fail;
14697 }
14698 resultobj = SWIG_From_int(static_cast< int >(result));
14699 return resultobj;
14700 fail:
14701 return NULL;
14702 }
14703
14704
14705 SWIGINTERN PyObject *_wrap_Joystick_GetPollingMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14706 PyObject *resultobj = 0;
14707 wxJoystick *arg1 = (wxJoystick *) 0 ;
14708 int result;
14709 void *argp1 = 0 ;
14710 int res1 = 0 ;
14711 PyObject *swig_obj[1] ;
14712
14713 if (!args) SWIG_fail;
14714 swig_obj[0] = args;
14715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14716 if (!SWIG_IsOK(res1)) {
14717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetPollingMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14718 }
14719 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14720 {
14721 PyThreadState* __tstate = wxPyBeginAllowThreads();
14722 result = (int)(arg1)->GetPollingMax();
14723 wxPyEndAllowThreads(__tstate);
14724 if (PyErr_Occurred()) SWIG_fail;
14725 }
14726 resultobj = SWIG_From_int(static_cast< int >(result));
14727 return resultobj;
14728 fail:
14729 return NULL;
14730 }
14731
14732
14733 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14734 PyObject *resultobj = 0;
14735 wxJoystick *arg1 = (wxJoystick *) 0 ;
14736 int result;
14737 void *argp1 = 0 ;
14738 int res1 = 0 ;
14739 PyObject *swig_obj[1] ;
14740
14741 if (!args) SWIG_fail;
14742 swig_obj[0] = args;
14743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14744 if (!SWIG_IsOK(res1)) {
14745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14746 }
14747 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14748 {
14749 PyThreadState* __tstate = wxPyBeginAllowThreads();
14750 result = (int)(arg1)->GetRudderMin();
14751 wxPyEndAllowThreads(__tstate);
14752 if (PyErr_Occurred()) SWIG_fail;
14753 }
14754 resultobj = SWIG_From_int(static_cast< int >(result));
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_Joystick_GetRudderMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14762 PyObject *resultobj = 0;
14763 wxJoystick *arg1 = (wxJoystick *) 0 ;
14764 int result;
14765 void *argp1 = 0 ;
14766 int res1 = 0 ;
14767 PyObject *swig_obj[1] ;
14768
14769 if (!args) SWIG_fail;
14770 swig_obj[0] = args;
14771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14772 if (!SWIG_IsOK(res1)) {
14773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetRudderMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14774 }
14775 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14776 {
14777 PyThreadState* __tstate = wxPyBeginAllowThreads();
14778 result = (int)(arg1)->GetRudderMax();
14779 wxPyEndAllowThreads(__tstate);
14780 if (PyErr_Occurred()) SWIG_fail;
14781 }
14782 resultobj = SWIG_From_int(static_cast< int >(result));
14783 return resultobj;
14784 fail:
14785 return NULL;
14786 }
14787
14788
14789 SWIGINTERN PyObject *_wrap_Joystick_GetUMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14790 PyObject *resultobj = 0;
14791 wxJoystick *arg1 = (wxJoystick *) 0 ;
14792 int result;
14793 void *argp1 = 0 ;
14794 int res1 = 0 ;
14795 PyObject *swig_obj[1] ;
14796
14797 if (!args) SWIG_fail;
14798 swig_obj[0] = args;
14799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14800 if (!SWIG_IsOK(res1)) {
14801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14802 }
14803 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14804 {
14805 PyThreadState* __tstate = wxPyBeginAllowThreads();
14806 result = (int)(arg1)->GetUMin();
14807 wxPyEndAllowThreads(__tstate);
14808 if (PyErr_Occurred()) SWIG_fail;
14809 }
14810 resultobj = SWIG_From_int(static_cast< int >(result));
14811 return resultobj;
14812 fail:
14813 return NULL;
14814 }
14815
14816
14817 SWIGINTERN PyObject *_wrap_Joystick_GetUMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14818 PyObject *resultobj = 0;
14819 wxJoystick *arg1 = (wxJoystick *) 0 ;
14820 int result;
14821 void *argp1 = 0 ;
14822 int res1 = 0 ;
14823 PyObject *swig_obj[1] ;
14824
14825 if (!args) SWIG_fail;
14826 swig_obj[0] = args;
14827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14828 if (!SWIG_IsOK(res1)) {
14829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetUMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14830 }
14831 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14832 {
14833 PyThreadState* __tstate = wxPyBeginAllowThreads();
14834 result = (int)(arg1)->GetUMax();
14835 wxPyEndAllowThreads(__tstate);
14836 if (PyErr_Occurred()) SWIG_fail;
14837 }
14838 resultobj = SWIG_From_int(static_cast< int >(result));
14839 return resultobj;
14840 fail:
14841 return NULL;
14842 }
14843
14844
14845 SWIGINTERN PyObject *_wrap_Joystick_GetVMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14846 PyObject *resultobj = 0;
14847 wxJoystick *arg1 = (wxJoystick *) 0 ;
14848 int result;
14849 void *argp1 = 0 ;
14850 int res1 = 0 ;
14851 PyObject *swig_obj[1] ;
14852
14853 if (!args) SWIG_fail;
14854 swig_obj[0] = args;
14855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14856 if (!SWIG_IsOK(res1)) {
14857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMin" "', expected argument " "1"" of type '" "wxJoystick *""'");
14858 }
14859 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 result = (int)(arg1)->GetVMin();
14863 wxPyEndAllowThreads(__tstate);
14864 if (PyErr_Occurred()) SWIG_fail;
14865 }
14866 resultobj = SWIG_From_int(static_cast< int >(result));
14867 return resultobj;
14868 fail:
14869 return NULL;
14870 }
14871
14872
14873 SWIGINTERN PyObject *_wrap_Joystick_GetVMax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14874 PyObject *resultobj = 0;
14875 wxJoystick *arg1 = (wxJoystick *) 0 ;
14876 int result;
14877 void *argp1 = 0 ;
14878 int res1 = 0 ;
14879 PyObject *swig_obj[1] ;
14880
14881 if (!args) SWIG_fail;
14882 swig_obj[0] = args;
14883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14884 if (!SWIG_IsOK(res1)) {
14885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_GetVMax" "', expected argument " "1"" of type '" "wxJoystick *""'");
14886 }
14887 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14888 {
14889 PyThreadState* __tstate = wxPyBeginAllowThreads();
14890 result = (int)(arg1)->GetVMax();
14891 wxPyEndAllowThreads(__tstate);
14892 if (PyErr_Occurred()) SWIG_fail;
14893 }
14894 resultobj = SWIG_From_int(static_cast< int >(result));
14895 return resultobj;
14896 fail:
14897 return NULL;
14898 }
14899
14900
14901 SWIGINTERN PyObject *_wrap_Joystick_HasRudder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14902 PyObject *resultobj = 0;
14903 wxJoystick *arg1 = (wxJoystick *) 0 ;
14904 bool result;
14905 void *argp1 = 0 ;
14906 int res1 = 0 ;
14907 PyObject *swig_obj[1] ;
14908
14909 if (!args) SWIG_fail;
14910 swig_obj[0] = args;
14911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14912 if (!SWIG_IsOK(res1)) {
14913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasRudder" "', expected argument " "1"" of type '" "wxJoystick *""'");
14914 }
14915 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (bool)(arg1)->HasRudder();
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 {
14923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14924 }
14925 return resultobj;
14926 fail:
14927 return NULL;
14928 }
14929
14930
14931 SWIGINTERN PyObject *_wrap_Joystick_HasZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14932 PyObject *resultobj = 0;
14933 wxJoystick *arg1 = (wxJoystick *) 0 ;
14934 bool result;
14935 void *argp1 = 0 ;
14936 int res1 = 0 ;
14937 PyObject *swig_obj[1] ;
14938
14939 if (!args) SWIG_fail;
14940 swig_obj[0] = args;
14941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14942 if (!SWIG_IsOK(res1)) {
14943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasZ" "', expected argument " "1"" of type '" "wxJoystick *""'");
14944 }
14945 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14946 {
14947 PyThreadState* __tstate = wxPyBeginAllowThreads();
14948 result = (bool)(arg1)->HasZ();
14949 wxPyEndAllowThreads(__tstate);
14950 if (PyErr_Occurred()) SWIG_fail;
14951 }
14952 {
14953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14954 }
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 SWIGINTERN PyObject *_wrap_Joystick_HasU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14962 PyObject *resultobj = 0;
14963 wxJoystick *arg1 = (wxJoystick *) 0 ;
14964 bool result;
14965 void *argp1 = 0 ;
14966 int res1 = 0 ;
14967 PyObject *swig_obj[1] ;
14968
14969 if (!args) SWIG_fail;
14970 swig_obj[0] = args;
14971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
14972 if (!SWIG_IsOK(res1)) {
14973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasU" "', expected argument " "1"" of type '" "wxJoystick *""'");
14974 }
14975 arg1 = reinterpret_cast< wxJoystick * >(argp1);
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (bool)(arg1)->HasU();
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 {
14983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14984 }
14985 return resultobj;
14986 fail:
14987 return NULL;
14988 }
14989
14990
14991 SWIGINTERN PyObject *_wrap_Joystick_HasV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14992 PyObject *resultobj = 0;
14993 wxJoystick *arg1 = (wxJoystick *) 0 ;
14994 bool result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 PyObject *swig_obj[1] ;
14998
14999 if (!args) SWIG_fail;
15000 swig_obj[0] = args;
15001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15002 if (!SWIG_IsOK(res1)) {
15003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15004 }
15005 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15006 {
15007 PyThreadState* __tstate = wxPyBeginAllowThreads();
15008 result = (bool)(arg1)->HasV();
15009 wxPyEndAllowThreads(__tstate);
15010 if (PyErr_Occurred()) SWIG_fail;
15011 }
15012 {
15013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15014 }
15015 return resultobj;
15016 fail:
15017 return NULL;
15018 }
15019
15020
15021 SWIGINTERN PyObject *_wrap_Joystick_HasPOV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15022 PyObject *resultobj = 0;
15023 wxJoystick *arg1 = (wxJoystick *) 0 ;
15024 bool 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_HasPOV" "', expected argument " "1"" of type '" "wxJoystick *""'");
15034 }
15035 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15036 {
15037 PyThreadState* __tstate = wxPyBeginAllowThreads();
15038 result = (bool)(arg1)->HasPOV();
15039 wxPyEndAllowThreads(__tstate);
15040 if (PyErr_Occurred()) SWIG_fail;
15041 }
15042 {
15043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15044 }
15045 return resultobj;
15046 fail:
15047 return NULL;
15048 }
15049
15050
15051 SWIGINTERN PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15052 PyObject *resultobj = 0;
15053 wxJoystick *arg1 = (wxJoystick *) 0 ;
15054 bool result;
15055 void *argp1 = 0 ;
15056 int res1 = 0 ;
15057 PyObject *swig_obj[1] ;
15058
15059 if (!args) SWIG_fail;
15060 swig_obj[0] = args;
15061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15062 if (!SWIG_IsOK(res1)) {
15063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOV4Dir" "', expected argument " "1"" of type '" "wxJoystick *""'");
15064 }
15065 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15066 {
15067 PyThreadState* __tstate = wxPyBeginAllowThreads();
15068 result = (bool)(arg1)->HasPOV4Dir();
15069 wxPyEndAllowThreads(__tstate);
15070 if (PyErr_Occurred()) SWIG_fail;
15071 }
15072 {
15073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15074 }
15075 return resultobj;
15076 fail:
15077 return NULL;
15078 }
15079
15080
15081 SWIGINTERN PyObject *_wrap_Joystick_HasPOVCTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15082 PyObject *resultobj = 0;
15083 wxJoystick *arg1 = (wxJoystick *) 0 ;
15084 bool result;
15085 void *argp1 = 0 ;
15086 int res1 = 0 ;
15087 PyObject *swig_obj[1] ;
15088
15089 if (!args) SWIG_fail;
15090 swig_obj[0] = args;
15091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15092 if (!SWIG_IsOK(res1)) {
15093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_HasPOVCTS" "', expected argument " "1"" of type '" "wxJoystick *""'");
15094 }
15095 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15096 {
15097 PyThreadState* __tstate = wxPyBeginAllowThreads();
15098 result = (bool)(arg1)->HasPOVCTS();
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 {
15103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15104 }
15105 return resultobj;
15106 fail:
15107 return NULL;
15108 }
15109
15110
15111 SWIGINTERN PyObject *_wrap_Joystick_SetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15112 PyObject *resultobj = 0;
15113 wxJoystick *arg1 = (wxJoystick *) 0 ;
15114 wxWindow *arg2 = (wxWindow *) 0 ;
15115 int arg3 = (int) 0 ;
15116 bool result;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 void *argp2 = 0 ;
15120 int res2 = 0 ;
15121 int val3 ;
15122 int ecode3 = 0 ;
15123 PyObject * obj0 = 0 ;
15124 PyObject * obj1 = 0 ;
15125 PyObject * obj2 = 0 ;
15126 char * kwnames[] = {
15127 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
15128 };
15129
15130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15132 if (!SWIG_IsOK(res1)) {
15133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_SetCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15134 }
15135 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
15137 if (!SWIG_IsOK(res2)) {
15138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Joystick_SetCapture" "', expected argument " "2"" of type '" "wxWindow *""'");
15139 }
15140 arg2 = reinterpret_cast< wxWindow * >(argp2);
15141 if (obj2) {
15142 ecode3 = SWIG_AsVal_int(obj2, &val3);
15143 if (!SWIG_IsOK(ecode3)) {
15144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Joystick_SetCapture" "', expected argument " "3"" of type '" "int""'");
15145 }
15146 arg3 = static_cast< int >(val3);
15147 }
15148 {
15149 PyThreadState* __tstate = wxPyBeginAllowThreads();
15150 result = (bool)(arg1)->SetCapture(arg2,arg3);
15151 wxPyEndAllowThreads(__tstate);
15152 if (PyErr_Occurred()) SWIG_fail;
15153 }
15154 {
15155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15156 }
15157 return resultobj;
15158 fail:
15159 return NULL;
15160 }
15161
15162
15163 SWIGINTERN PyObject *_wrap_Joystick_ReleaseCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15164 PyObject *resultobj = 0;
15165 wxJoystick *arg1 = (wxJoystick *) 0 ;
15166 bool result;
15167 void *argp1 = 0 ;
15168 int res1 = 0 ;
15169 PyObject *swig_obj[1] ;
15170
15171 if (!args) SWIG_fail;
15172 swig_obj[0] = args;
15173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystick, 0 | 0 );
15174 if (!SWIG_IsOK(res1)) {
15175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Joystick_ReleaseCapture" "', expected argument " "1"" of type '" "wxJoystick *""'");
15176 }
15177 arg1 = reinterpret_cast< wxJoystick * >(argp1);
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = (bool)(arg1)->ReleaseCapture();
15181 wxPyEndAllowThreads(__tstate);
15182 if (PyErr_Occurred()) SWIG_fail;
15183 }
15184 {
15185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15186 }
15187 return resultobj;
15188 fail:
15189 return NULL;
15190 }
15191
15192
15193 SWIGINTERN PyObject *Joystick_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15194 PyObject *obj;
15195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15196 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystick, SWIG_NewClientData(obj));
15197 return SWIG_Py_Void();
15198 }
15199
15200 SWIGINTERN PyObject *Joystick_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15201 return SWIG_Python_InitShadowInstance(args);
15202 }
15203
15204 SWIGINTERN PyObject *_wrap_new_JoystickEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15205 PyObject *resultobj = 0;
15206 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15207 int arg2 = (int) 0 ;
15208 int arg3 = (int) wxJOYSTICK1 ;
15209 int arg4 = (int) 0 ;
15210 wxJoystickEvent *result = 0 ;
15211 int val1 ;
15212 int ecode1 = 0 ;
15213 int val2 ;
15214 int ecode2 = 0 ;
15215 int val3 ;
15216 int ecode3 = 0 ;
15217 int val4 ;
15218 int ecode4 = 0 ;
15219 PyObject * obj0 = 0 ;
15220 PyObject * obj1 = 0 ;
15221 PyObject * obj2 = 0 ;
15222 PyObject * obj3 = 0 ;
15223 char * kwnames[] = {
15224 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
15225 };
15226
15227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15228 if (obj0) {
15229 ecode1 = SWIG_AsVal_int(obj0, &val1);
15230 if (!SWIG_IsOK(ecode1)) {
15231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JoystickEvent" "', expected argument " "1"" of type '" "wxEventType""'");
15232 }
15233 arg1 = static_cast< wxEventType >(val1);
15234 }
15235 if (obj1) {
15236 ecode2 = SWIG_AsVal_int(obj1, &val2);
15237 if (!SWIG_IsOK(ecode2)) {
15238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JoystickEvent" "', expected argument " "2"" of type '" "int""'");
15239 }
15240 arg2 = static_cast< int >(val2);
15241 }
15242 if (obj2) {
15243 ecode3 = SWIG_AsVal_int(obj2, &val3);
15244 if (!SWIG_IsOK(ecode3)) {
15245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_JoystickEvent" "', expected argument " "3"" of type '" "int""'");
15246 }
15247 arg3 = static_cast< int >(val3);
15248 }
15249 if (obj3) {
15250 ecode4 = SWIG_AsVal_int(obj3, &val4);
15251 if (!SWIG_IsOK(ecode4)) {
15252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_JoystickEvent" "', expected argument " "4"" of type '" "int""'");
15253 }
15254 arg4 = static_cast< int >(val4);
15255 }
15256 {
15257 PyThreadState* __tstate = wxPyBeginAllowThreads();
15258 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
15259 wxPyEndAllowThreads(__tstate);
15260 if (PyErr_Occurred()) SWIG_fail;
15261 }
15262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_NEW | 0 );
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 SWIGINTERN PyObject *_wrap_JoystickEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15270 PyObject *resultobj = 0;
15271 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15272 wxPoint result;
15273 void *argp1 = 0 ;
15274 int res1 = 0 ;
15275 PyObject *swig_obj[1] ;
15276
15277 if (!args) SWIG_fail;
15278 swig_obj[0] = args;
15279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15280 if (!SWIG_IsOK(res1)) {
15281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15282 }
15283 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15284 {
15285 PyThreadState* __tstate = wxPyBeginAllowThreads();
15286 result = ((wxJoystickEvent const *)arg1)->GetPosition();
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 SWIGINTERN PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15298 PyObject *resultobj = 0;
15299 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15300 int result;
15301 void *argp1 = 0 ;
15302 int res1 = 0 ;
15303 PyObject *swig_obj[1] ;
15304
15305 if (!args) SWIG_fail;
15306 swig_obj[0] = args;
15307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15308 if (!SWIG_IsOK(res1)) {
15309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15310 }
15311 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
15315 wxPyEndAllowThreads(__tstate);
15316 if (PyErr_Occurred()) SWIG_fail;
15317 }
15318 resultobj = SWIG_From_int(static_cast< int >(result));
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15326 PyObject *resultobj = 0;
15327 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15328 int result;
15329 void *argp1 = 0 ;
15330 int res1 = 0 ;
15331 PyObject *swig_obj[1] ;
15332
15333 if (!args) SWIG_fail;
15334 swig_obj[0] = args;
15335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15336 if (!SWIG_IsOK(res1)) {
15337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15338 }
15339 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15340 {
15341 PyThreadState* __tstate = wxPyBeginAllowThreads();
15342 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
15343 wxPyEndAllowThreads(__tstate);
15344 if (PyErr_Occurred()) SWIG_fail;
15345 }
15346 resultobj = SWIG_From_int(static_cast< int >(result));
15347 return resultobj;
15348 fail:
15349 return NULL;
15350 }
15351
15352
15353 SWIGINTERN PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15354 PyObject *resultobj = 0;
15355 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15356 int result;
15357 void *argp1 = 0 ;
15358 int res1 = 0 ;
15359 PyObject *swig_obj[1] ;
15360
15361 if (!args) SWIG_fail;
15362 swig_obj[0] = args;
15363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15364 if (!SWIG_IsOK(res1)) {
15365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15366 }
15367 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15368 {
15369 PyThreadState* __tstate = wxPyBeginAllowThreads();
15370 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 resultobj = SWIG_From_int(static_cast< int >(result));
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 SWIGINTERN PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15382 PyObject *resultobj = 0;
15383 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15384 int result;
15385 void *argp1 = 0 ;
15386 int res1 = 0 ;
15387 PyObject *swig_obj[1] ;
15388
15389 if (!args) SWIG_fail;
15390 swig_obj[0] = args;
15391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15392 if (!SWIG_IsOK(res1)) {
15393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_GetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15394 }
15395 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15396 {
15397 PyThreadState* __tstate = wxPyBeginAllowThreads();
15398 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
15399 wxPyEndAllowThreads(__tstate);
15400 if (PyErr_Occurred()) SWIG_fail;
15401 }
15402 resultobj = SWIG_From_int(static_cast< int >(result));
15403 return resultobj;
15404 fail:
15405 return NULL;
15406 }
15407
15408
15409 SWIGINTERN PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15410 PyObject *resultobj = 0;
15411 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15412 int arg2 ;
15413 void *argp1 = 0 ;
15414 int res1 = 0 ;
15415 int val2 ;
15416 int ecode2 = 0 ;
15417 PyObject * obj0 = 0 ;
15418 PyObject * obj1 = 0 ;
15419 char * kwnames[] = {
15420 (char *) "self",(char *) "stick", NULL
15421 };
15422
15423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) SWIG_fail;
15424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15425 if (!SWIG_IsOK(res1)) {
15426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15427 }
15428 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15429 ecode2 = SWIG_AsVal_int(obj1, &val2);
15430 if (!SWIG_IsOK(ecode2)) {
15431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetJoystick" "', expected argument " "2"" of type '" "int""'");
15432 }
15433 arg2 = static_cast< int >(val2);
15434 {
15435 PyThreadState* __tstate = wxPyBeginAllowThreads();
15436 (arg1)->SetJoystick(arg2);
15437 wxPyEndAllowThreads(__tstate);
15438 if (PyErr_Occurred()) SWIG_fail;
15439 }
15440 resultobj = SWIG_Py_Void();
15441 return resultobj;
15442 fail:
15443 return NULL;
15444 }
15445
15446
15447 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15448 PyObject *resultobj = 0;
15449 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15450 int arg2 ;
15451 void *argp1 = 0 ;
15452 int res1 = 0 ;
15453 int val2 ;
15454 int ecode2 = 0 ;
15455 PyObject * obj0 = 0 ;
15456 PyObject * obj1 = 0 ;
15457 char * kwnames[] = {
15458 (char *) "self",(char *) "state", NULL
15459 };
15460
15461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) SWIG_fail;
15462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15463 if (!SWIG_IsOK(res1)) {
15464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15465 }
15466 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15467 ecode2 = SWIG_AsVal_int(obj1, &val2);
15468 if (!SWIG_IsOK(ecode2)) {
15469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonState" "', expected argument " "2"" of type '" "int""'");
15470 }
15471 arg2 = static_cast< int >(val2);
15472 {
15473 PyThreadState* __tstate = wxPyBeginAllowThreads();
15474 (arg1)->SetButtonState(arg2);
15475 wxPyEndAllowThreads(__tstate);
15476 if (PyErr_Occurred()) SWIG_fail;
15477 }
15478 resultobj = SWIG_Py_Void();
15479 return resultobj;
15480 fail:
15481 return NULL;
15482 }
15483
15484
15485 SWIGINTERN PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15486 PyObject *resultobj = 0;
15487 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15488 int arg2 ;
15489 void *argp1 = 0 ;
15490 int res1 = 0 ;
15491 int val2 ;
15492 int ecode2 = 0 ;
15493 PyObject * obj0 = 0 ;
15494 PyObject * obj1 = 0 ;
15495 char * kwnames[] = {
15496 (char *) "self",(char *) "change", NULL
15497 };
15498
15499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) SWIG_fail;
15500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15501 if (!SWIG_IsOK(res1)) {
15502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15503 }
15504 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15505 ecode2 = SWIG_AsVal_int(obj1, &val2);
15506 if (!SWIG_IsOK(ecode2)) {
15507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetButtonChange" "', expected argument " "2"" of type '" "int""'");
15508 }
15509 arg2 = static_cast< int >(val2);
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 (arg1)->SetButtonChange(arg2);
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 resultobj = SWIG_Py_Void();
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_JoystickEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15524 PyObject *resultobj = 0;
15525 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15526 wxPoint *arg2 = 0 ;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 wxPoint temp2 ;
15530 PyObject * obj0 = 0 ;
15531 PyObject * obj1 = 0 ;
15532 char * kwnames[] = {
15533 (char *) "self",(char *) "pos", NULL
15534 };
15535
15536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15538 if (!SWIG_IsOK(res1)) {
15539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15540 }
15541 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15542 {
15543 arg2 = &temp2;
15544 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
15545 }
15546 {
15547 PyThreadState* __tstate = wxPyBeginAllowThreads();
15548 (arg1)->SetPosition((wxPoint const &)*arg2);
15549 wxPyEndAllowThreads(__tstate);
15550 if (PyErr_Occurred()) SWIG_fail;
15551 }
15552 resultobj = SWIG_Py_Void();
15553 return resultobj;
15554 fail:
15555 return NULL;
15556 }
15557
15558
15559 SWIGINTERN PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15560 PyObject *resultobj = 0;
15561 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15562 int arg2 ;
15563 void *argp1 = 0 ;
15564 int res1 = 0 ;
15565 int val2 ;
15566 int ecode2 = 0 ;
15567 PyObject * obj0 = 0 ;
15568 PyObject * obj1 = 0 ;
15569 char * kwnames[] = {
15570 (char *) "self",(char *) "zPos", NULL
15571 };
15572
15573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) SWIG_fail;
15574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15575 if (!SWIG_IsOK(res1)) {
15576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "1"" of type '" "wxJoystickEvent *""'");
15577 }
15578 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15579 ecode2 = SWIG_AsVal_int(obj1, &val2);
15580 if (!SWIG_IsOK(ecode2)) {
15581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_SetZPosition" "', expected argument " "2"" of type '" "int""'");
15582 }
15583 arg2 = static_cast< int >(val2);
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 (arg1)->SetZPosition(arg2);
15587 wxPyEndAllowThreads(__tstate);
15588 if (PyErr_Occurred()) SWIG_fail;
15589 }
15590 resultobj = SWIG_Py_Void();
15591 return resultobj;
15592 fail:
15593 return NULL;
15594 }
15595
15596
15597 SWIGINTERN PyObject *_wrap_JoystickEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15598 PyObject *resultobj = 0;
15599 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15600 bool result;
15601 void *argp1 = 0 ;
15602 int res1 = 0 ;
15603 PyObject *swig_obj[1] ;
15604
15605 if (!args) SWIG_fail;
15606 swig_obj[0] = args;
15607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15608 if (!SWIG_IsOK(res1)) {
15609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsButton" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15610 }
15611 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15612 {
15613 PyThreadState* __tstate = wxPyBeginAllowThreads();
15614 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 {
15619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15620 }
15621 return resultobj;
15622 fail:
15623 return NULL;
15624 }
15625
15626
15627 SWIGINTERN PyObject *_wrap_JoystickEvent_IsMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15628 PyObject *resultobj = 0;
15629 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15630 bool result;
15631 void *argp1 = 0 ;
15632 int res1 = 0 ;
15633 PyObject *swig_obj[1] ;
15634
15635 if (!args) SWIG_fail;
15636 swig_obj[0] = args;
15637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15638 if (!SWIG_IsOK(res1)) {
15639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15640 }
15641 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15642 {
15643 PyThreadState* __tstate = wxPyBeginAllowThreads();
15644 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
15645 wxPyEndAllowThreads(__tstate);
15646 if (PyErr_Occurred()) SWIG_fail;
15647 }
15648 {
15649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15650 }
15651 return resultobj;
15652 fail:
15653 return NULL;
15654 }
15655
15656
15657 SWIGINTERN PyObject *_wrap_JoystickEvent_IsZMove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15658 PyObject *resultobj = 0;
15659 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15660 bool result;
15661 void *argp1 = 0 ;
15662 int res1 = 0 ;
15663 PyObject *swig_obj[1] ;
15664
15665 if (!args) SWIG_fail;
15666 swig_obj[0] = args;
15667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15668 if (!SWIG_IsOK(res1)) {
15669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_IsZMove" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15670 }
15671 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15672 {
15673 PyThreadState* __tstate = wxPyBeginAllowThreads();
15674 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
15675 wxPyEndAllowThreads(__tstate);
15676 if (PyErr_Occurred()) SWIG_fail;
15677 }
15678 {
15679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15680 }
15681 return resultobj;
15682 fail:
15683 return NULL;
15684 }
15685
15686
15687 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15688 PyObject *resultobj = 0;
15689 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15690 int arg2 = (int) wxJOY_BUTTON_ANY ;
15691 bool result;
15692 void *argp1 = 0 ;
15693 int res1 = 0 ;
15694 int val2 ;
15695 int ecode2 = 0 ;
15696 PyObject * obj0 = 0 ;
15697 PyObject * obj1 = 0 ;
15698 char * kwnames[] = {
15699 (char *) "self",(char *) "but", NULL
15700 };
15701
15702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
15703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15704 if (!SWIG_IsOK(res1)) {
15705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15706 }
15707 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15708 if (obj1) {
15709 ecode2 = SWIG_AsVal_int(obj1, &val2);
15710 if (!SWIG_IsOK(ecode2)) {
15711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
15712 }
15713 arg2 = static_cast< int >(val2);
15714 }
15715 {
15716 PyThreadState* __tstate = wxPyBeginAllowThreads();
15717 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
15718 wxPyEndAllowThreads(__tstate);
15719 if (PyErr_Occurred()) SWIG_fail;
15720 }
15721 {
15722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15723 }
15724 return resultobj;
15725 fail:
15726 return NULL;
15727 }
15728
15729
15730 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15731 PyObject *resultobj = 0;
15732 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15733 int arg2 = (int) wxJOY_BUTTON_ANY ;
15734 bool result;
15735 void *argp1 = 0 ;
15736 int res1 = 0 ;
15737 int val2 ;
15738 int ecode2 = 0 ;
15739 PyObject * obj0 = 0 ;
15740 PyObject * obj1 = 0 ;
15741 char * kwnames[] = {
15742 (char *) "self",(char *) "but", NULL
15743 };
15744
15745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
15746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15747 if (!SWIG_IsOK(res1)) {
15748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15749 }
15750 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15751 if (obj1) {
15752 ecode2 = SWIG_AsVal_int(obj1, &val2);
15753 if (!SWIG_IsOK(ecode2)) {
15754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
15755 }
15756 arg2 = static_cast< int >(val2);
15757 }
15758 {
15759 PyThreadState* __tstate = wxPyBeginAllowThreads();
15760 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
15761 wxPyEndAllowThreads(__tstate);
15762 if (PyErr_Occurred()) SWIG_fail;
15763 }
15764 {
15765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15766 }
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 SWIGINTERN PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj = 0;
15775 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
15776 int arg2 = (int) wxJOY_BUTTON_ANY ;
15777 bool result;
15778 void *argp1 = 0 ;
15779 int res1 = 0 ;
15780 int val2 ;
15781 int ecode2 = 0 ;
15782 PyObject * obj0 = 0 ;
15783 PyObject * obj1 = 0 ;
15784 char * kwnames[] = {
15785 (char *) "self",(char *) "but", NULL
15786 };
15787
15788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
15789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxJoystickEvent, 0 | 0 );
15790 if (!SWIG_IsOK(res1)) {
15791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxJoystickEvent const *""'");
15792 }
15793 arg1 = reinterpret_cast< wxJoystickEvent * >(argp1);
15794 if (obj1) {
15795 ecode2 = SWIG_AsVal_int(obj1, &val2);
15796 if (!SWIG_IsOK(ecode2)) {
15797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JoystickEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
15798 }
15799 arg2 = static_cast< int >(val2);
15800 }
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 {
15808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15809 }
15810 return resultobj;
15811 fail:
15812 return NULL;
15813 }
15814
15815
15816 SWIGINTERN PyObject *JoystickEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15817 PyObject *obj;
15818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15819 SWIG_TypeNewClientData(SWIGTYPE_p_wxJoystickEvent, SWIG_NewClientData(obj));
15820 return SWIG_Py_Void();
15821 }
15822
15823 SWIGINTERN PyObject *JoystickEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15824 return SWIG_Python_InitShadowInstance(args);
15825 }
15826
15827 SWIGINTERN PyObject *_wrap_new_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15828 PyObject *resultobj = 0;
15829 wxString const &arg1_defvalue = wxPyEmptyString ;
15830 wxString *arg1 = (wxString *) &arg1_defvalue ;
15831 wxSound *result = 0 ;
15832 bool temp1 = false ;
15833 PyObject * obj0 = 0 ;
15834 char * kwnames[] = {
15835 (char *) "fileName", NULL
15836 };
15837
15838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) SWIG_fail;
15839 if (obj0) {
15840 {
15841 arg1 = wxString_in_helper(obj0);
15842 if (arg1 == NULL) SWIG_fail;
15843 temp1 = true;
15844 }
15845 }
15846 {
15847 if (!wxPyCheckForApp()) SWIG_fail;
15848 PyThreadState* __tstate = wxPyBeginAllowThreads();
15849 result = (wxSound *)new_wxSound((wxString const &)*arg1);
15850 wxPyEndAllowThreads(__tstate);
15851 if (PyErr_Occurred()) SWIG_fail;
15852 }
15853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_NEW | 0 );
15854 {
15855 if (temp1)
15856 delete arg1;
15857 }
15858 return resultobj;
15859 fail:
15860 {
15861 if (temp1)
15862 delete arg1;
15863 }
15864 return NULL;
15865 }
15866
15867
15868 SWIGINTERN PyObject *_wrap_new_SoundFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15869 PyObject *resultobj = 0;
15870 PyObject *arg1 = (PyObject *) 0 ;
15871 wxSound *result = 0 ;
15872 PyObject * obj0 = 0 ;
15873 char * kwnames[] = {
15874 (char *) "data", NULL
15875 };
15876
15877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) SWIG_fail;
15878 arg1 = obj0;
15879 {
15880 if (!wxPyCheckForApp()) SWIG_fail;
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 result = (wxSound *)new_wxSound(arg1);
15883 wxPyEndAllowThreads(__tstate);
15884 if (PyErr_Occurred()) SWIG_fail;
15885 }
15886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSound, SWIG_POINTER_OWN | 0 );
15887 return resultobj;
15888 fail:
15889 return NULL;
15890 }
15891
15892
15893 SWIGINTERN PyObject *_wrap_delete_Sound(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15894 PyObject *resultobj = 0;
15895 wxSound *arg1 = (wxSound *) 0 ;
15896 void *argp1 = 0 ;
15897 int res1 = 0 ;
15898 PyObject *swig_obj[1] ;
15899
15900 if (!args) SWIG_fail;
15901 swig_obj[0] = args;
15902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, SWIG_POINTER_DISOWN | 0 );
15903 if (!SWIG_IsOK(res1)) {
15904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sound" "', expected argument " "1"" of type '" "wxSound *""'");
15905 }
15906 arg1 = reinterpret_cast< wxSound * >(argp1);
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 delete arg1;
15910
15911 wxPyEndAllowThreads(__tstate);
15912 if (PyErr_Occurred()) SWIG_fail;
15913 }
15914 resultobj = SWIG_Py_Void();
15915 return resultobj;
15916 fail:
15917 return NULL;
15918 }
15919
15920
15921 SWIGINTERN PyObject *_wrap_Sound_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15922 PyObject *resultobj = 0;
15923 wxSound *arg1 = (wxSound *) 0 ;
15924 wxString *arg2 = 0 ;
15925 bool result;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 bool temp2 = false ;
15929 PyObject * obj0 = 0 ;
15930 PyObject * obj1 = 0 ;
15931 char * kwnames[] = {
15932 (char *) "self",(char *) "fileName", NULL
15933 };
15934
15935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) SWIG_fail;
15936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15937 if (!SWIG_IsOK(res1)) {
15938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Create" "', expected argument " "1"" of type '" "wxSound *""'");
15939 }
15940 arg1 = reinterpret_cast< wxSound * >(argp1);
15941 {
15942 arg2 = wxString_in_helper(obj1);
15943 if (arg2 == NULL) SWIG_fail;
15944 temp2 = true;
15945 }
15946 {
15947 PyThreadState* __tstate = wxPyBeginAllowThreads();
15948 result = (bool)(arg1)->Create((wxString const &)*arg2);
15949 wxPyEndAllowThreads(__tstate);
15950 if (PyErr_Occurred()) SWIG_fail;
15951 }
15952 {
15953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15954 }
15955 {
15956 if (temp2)
15957 delete arg2;
15958 }
15959 return resultobj;
15960 fail:
15961 {
15962 if (temp2)
15963 delete arg2;
15964 }
15965 return NULL;
15966 }
15967
15968
15969 SWIGINTERN PyObject *_wrap_Sound_CreateFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15970 PyObject *resultobj = 0;
15971 wxSound *arg1 = (wxSound *) 0 ;
15972 PyObject *arg2 = (PyObject *) 0 ;
15973 bool result;
15974 void *argp1 = 0 ;
15975 int res1 = 0 ;
15976 PyObject * obj0 = 0 ;
15977 PyObject * obj1 = 0 ;
15978 char * kwnames[] = {
15979 (char *) "self",(char *) "data", NULL
15980 };
15981
15982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) SWIG_fail;
15983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
15984 if (!SWIG_IsOK(res1)) {
15985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_CreateFromData" "', expected argument " "1"" of type '" "wxSound *""'");
15986 }
15987 arg1 = reinterpret_cast< wxSound * >(argp1);
15988 arg2 = obj1;
15989 {
15990 PyThreadState* __tstate = wxPyBeginAllowThreads();
15991 result = (bool)wxSound_CreateFromData(arg1,arg2);
15992 wxPyEndAllowThreads(__tstate);
15993 if (PyErr_Occurred()) SWIG_fail;
15994 }
15995 {
15996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15997 }
15998 return resultobj;
15999 fail:
16000 return NULL;
16001 }
16002
16003
16004 SWIGINTERN PyObject *_wrap_Sound_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16005 PyObject *resultobj = 0;
16006 wxSound *arg1 = (wxSound *) 0 ;
16007 bool result;
16008 void *argp1 = 0 ;
16009 int res1 = 0 ;
16010 PyObject *swig_obj[1] ;
16011
16012 if (!args) SWIG_fail;
16013 swig_obj[0] = args;
16014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16015 if (!SWIG_IsOK(res1)) {
16016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_IsOk" "', expected argument " "1"" of type '" "wxSound *""'");
16017 }
16018 arg1 = reinterpret_cast< wxSound * >(argp1);
16019 {
16020 PyThreadState* __tstate = wxPyBeginAllowThreads();
16021 result = (bool)(arg1)->IsOk();
16022 wxPyEndAllowThreads(__tstate);
16023 if (PyErr_Occurred()) SWIG_fail;
16024 }
16025 {
16026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16027 }
16028 return resultobj;
16029 fail:
16030 return NULL;
16031 }
16032
16033
16034 SWIGINTERN PyObject *_wrap_Sound_Play(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16035 PyObject *resultobj = 0;
16036 wxSound *arg1 = (wxSound *) 0 ;
16037 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16038 bool result;
16039 void *argp1 = 0 ;
16040 int res1 = 0 ;
16041 unsigned int val2 ;
16042 int ecode2 = 0 ;
16043 PyObject * obj0 = 0 ;
16044 PyObject * obj1 = 0 ;
16045 char * kwnames[] = {
16046 (char *) "self",(char *) "flags", NULL
16047 };
16048
16049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) SWIG_fail;
16050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSound, 0 | 0 );
16051 if (!SWIG_IsOK(res1)) {
16052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sound_Play" "', expected argument " "1"" of type '" "wxSound const *""'");
16053 }
16054 arg1 = reinterpret_cast< wxSound * >(argp1);
16055 if (obj1) {
16056 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16057 if (!SWIG_IsOK(ecode2)) {
16058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_Play" "', expected argument " "2"" of type '" "unsigned int""'");
16059 }
16060 arg2 = static_cast< unsigned int >(val2);
16061 }
16062 {
16063 if (!wxPyCheckForApp()) SWIG_fail;
16064 PyThreadState* __tstate = wxPyBeginAllowThreads();
16065 result = (bool)((wxSound const *)arg1)->Play(arg2);
16066 wxPyEndAllowThreads(__tstate);
16067 if (PyErr_Occurred()) SWIG_fail;
16068 }
16069 {
16070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16071 }
16072 return resultobj;
16073 fail:
16074 return NULL;
16075 }
16076
16077
16078 SWIGINTERN PyObject *_wrap_Sound_PlaySound(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16079 PyObject *resultobj = 0;
16080 wxString *arg1 = 0 ;
16081 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
16082 bool result;
16083 bool temp1 = false ;
16084 unsigned int val2 ;
16085 int ecode2 = 0 ;
16086 PyObject * obj0 = 0 ;
16087 PyObject * obj1 = 0 ;
16088 char * kwnames[] = {
16089 (char *) "filename",(char *) "flags", NULL
16090 };
16091
16092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) SWIG_fail;
16093 {
16094 arg1 = wxString_in_helper(obj0);
16095 if (arg1 == NULL) SWIG_fail;
16096 temp1 = true;
16097 }
16098 if (obj1) {
16099 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
16100 if (!SWIG_IsOK(ecode2)) {
16101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sound_PlaySound" "', expected argument " "2"" of type '" "unsigned int""'");
16102 }
16103 arg2 = static_cast< unsigned int >(val2);
16104 }
16105 {
16106 if (!wxPyCheckForApp()) SWIG_fail;
16107 PyThreadState* __tstate = wxPyBeginAllowThreads();
16108 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
16109 wxPyEndAllowThreads(__tstate);
16110 if (PyErr_Occurred()) SWIG_fail;
16111 }
16112 {
16113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16114 }
16115 {
16116 if (temp1)
16117 delete arg1;
16118 }
16119 return resultobj;
16120 fail:
16121 {
16122 if (temp1)
16123 delete arg1;
16124 }
16125 return NULL;
16126 }
16127
16128
16129 SWIGINTERN PyObject *_wrap_Sound_Stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16130 PyObject *resultobj = 0;
16131
16132 if (!SWIG_Python_UnpackTuple(args,"Sound_Stop",0,0,0)) SWIG_fail;
16133 {
16134 if (!wxPyCheckForApp()) SWIG_fail;
16135 PyThreadState* __tstate = wxPyBeginAllowThreads();
16136 wxSound::Stop();
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 resultobj = SWIG_Py_Void();
16141 return resultobj;
16142 fail:
16143 return NULL;
16144 }
16145
16146
16147 SWIGINTERN PyObject *Sound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16148 PyObject *obj;
16149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16150 SWIG_TypeNewClientData(SWIGTYPE_p_wxSound, SWIG_NewClientData(obj));
16151 return SWIG_Py_Void();
16152 }
16153
16154 SWIGINTERN PyObject *Sound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16155 return SWIG_Python_InitShadowInstance(args);
16156 }
16157
16158 SWIGINTERN PyObject *_wrap_new_FileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16159 PyObject *resultobj = 0;
16160 wxString *arg1 = 0 ;
16161 wxString *arg2 = 0 ;
16162 wxString *arg3 = 0 ;
16163 wxString *arg4 = 0 ;
16164 wxFileTypeInfo *result = 0 ;
16165 bool temp1 = false ;
16166 bool temp2 = false ;
16167 bool temp3 = false ;
16168 bool temp4 = false ;
16169 PyObject * obj0 = 0 ;
16170 PyObject * obj1 = 0 ;
16171 PyObject * obj2 = 0 ;
16172 PyObject * obj3 = 0 ;
16173 char * kwnames[] = {
16174 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
16175 };
16176
16177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16178 {
16179 arg1 = wxString_in_helper(obj0);
16180 if (arg1 == NULL) SWIG_fail;
16181 temp1 = true;
16182 }
16183 {
16184 arg2 = wxString_in_helper(obj1);
16185 if (arg2 == NULL) SWIG_fail;
16186 temp2 = true;
16187 }
16188 {
16189 arg3 = wxString_in_helper(obj2);
16190 if (arg3 == NULL) SWIG_fail;
16191 temp3 = true;
16192 }
16193 {
16194 arg4 = wxString_in_helper(obj3);
16195 if (arg4 == NULL) SWIG_fail;
16196 temp4 = true;
16197 }
16198 {
16199 PyThreadState* __tstate = wxPyBeginAllowThreads();
16200 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
16201 wxPyEndAllowThreads(__tstate);
16202 if (PyErr_Occurred()) SWIG_fail;
16203 }
16204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_NEW | 0 );
16205 {
16206 if (temp1)
16207 delete arg1;
16208 }
16209 {
16210 if (temp2)
16211 delete arg2;
16212 }
16213 {
16214 if (temp3)
16215 delete arg3;
16216 }
16217 {
16218 if (temp4)
16219 delete arg4;
16220 }
16221 return resultobj;
16222 fail:
16223 {
16224 if (temp1)
16225 delete arg1;
16226 }
16227 {
16228 if (temp2)
16229 delete arg2;
16230 }
16231 {
16232 if (temp3)
16233 delete arg3;
16234 }
16235 {
16236 if (temp4)
16237 delete arg4;
16238 }
16239 return NULL;
16240 }
16241
16242
16243 SWIGINTERN PyObject *_wrap_new_FileTypeInfoSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj = 0;
16245 wxArrayString *arg1 = 0 ;
16246 wxFileTypeInfo *result = 0 ;
16247 bool temp1 = false ;
16248 PyObject * obj0 = 0 ;
16249 char * kwnames[] = {
16250 (char *) "sArray", NULL
16251 };
16252
16253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) SWIG_fail;
16254 {
16255 if (! PySequence_Check(obj0)) {
16256 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
16257 SWIG_fail;
16258 }
16259 arg1 = new wxArrayString;
16260 temp1 = true;
16261 int i, len=PySequence_Length(obj0);
16262 for (i=0; i<len; i++) {
16263 PyObject* item = PySequence_GetItem(obj0, i);
16264 wxString* s = wxString_in_helper(item);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 arg1->Add(*s);
16267 delete s;
16268 Py_DECREF(item);
16269 }
16270 }
16271 {
16272 PyThreadState* __tstate = wxPyBeginAllowThreads();
16273 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
16274 wxPyEndAllowThreads(__tstate);
16275 if (PyErr_Occurred()) SWIG_fail;
16276 }
16277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16278 {
16279 if (temp1) delete arg1;
16280 }
16281 return resultobj;
16282 fail:
16283 {
16284 if (temp1) delete arg1;
16285 }
16286 return NULL;
16287 }
16288
16289
16290 SWIGINTERN PyObject *_wrap_new_NullFileTypeInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16291 PyObject *resultobj = 0;
16292 wxFileTypeInfo *result = 0 ;
16293
16294 if (!SWIG_Python_UnpackTuple(args,"new_NullFileTypeInfo",0,0,0)) SWIG_fail;
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (wxFileTypeInfo *)new wxFileTypeInfo();
16298 wxPyEndAllowThreads(__tstate);
16299 if (PyErr_Occurred()) SWIG_fail;
16300 }
16301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_OWN | 0 );
16302 return resultobj;
16303 fail:
16304 return NULL;
16305 }
16306
16307
16308 SWIGINTERN PyObject *_wrap_FileTypeInfo_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16309 PyObject *resultobj = 0;
16310 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16311 bool result;
16312 void *argp1 = 0 ;
16313 int res1 = 0 ;
16314 PyObject *swig_obj[1] ;
16315
16316 if (!args) SWIG_fail;
16317 swig_obj[0] = args;
16318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16319 if (!SWIG_IsOK(res1)) {
16320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_IsValid" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16321 }
16322 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16323 {
16324 PyThreadState* __tstate = wxPyBeginAllowThreads();
16325 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
16326 wxPyEndAllowThreads(__tstate);
16327 if (PyErr_Occurred()) SWIG_fail;
16328 }
16329 {
16330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16331 }
16332 return resultobj;
16333 fail:
16334 return NULL;
16335 }
16336
16337
16338 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16339 PyObject *resultobj = 0;
16340 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16341 wxString *arg2 = 0 ;
16342 int arg3 = (int) 0 ;
16343 void *argp1 = 0 ;
16344 int res1 = 0 ;
16345 bool temp2 = false ;
16346 int val3 ;
16347 int ecode3 = 0 ;
16348 PyObject * obj0 = 0 ;
16349 PyObject * obj1 = 0 ;
16350 PyObject * obj2 = 0 ;
16351 char * kwnames[] = {
16352 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
16353 };
16354
16355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16357 if (!SWIG_IsOK(res1)) {
16358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16359 }
16360 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16361 {
16362 arg2 = wxString_in_helper(obj1);
16363 if (arg2 == NULL) SWIG_fail;
16364 temp2 = true;
16365 }
16366 if (obj2) {
16367 ecode3 = SWIG_AsVal_int(obj2, &val3);
16368 if (!SWIG_IsOK(ecode3)) {
16369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileTypeInfo_SetIcon" "', expected argument " "3"" of type '" "int""'");
16370 }
16371 arg3 = static_cast< int >(val3);
16372 }
16373 {
16374 PyThreadState* __tstate = wxPyBeginAllowThreads();
16375 (arg1)->SetIcon((wxString const &)*arg2,arg3);
16376 wxPyEndAllowThreads(__tstate);
16377 if (PyErr_Occurred()) SWIG_fail;
16378 }
16379 resultobj = SWIG_Py_Void();
16380 {
16381 if (temp2)
16382 delete arg2;
16383 }
16384 return resultobj;
16385 fail:
16386 {
16387 if (temp2)
16388 delete arg2;
16389 }
16390 return NULL;
16391 }
16392
16393
16394 SWIGINTERN PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16395 PyObject *resultobj = 0;
16396 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16397 wxString *arg2 = 0 ;
16398 void *argp1 = 0 ;
16399 int res1 = 0 ;
16400 bool temp2 = false ;
16401 PyObject * obj0 = 0 ;
16402 PyObject * obj1 = 0 ;
16403 char * kwnames[] = {
16404 (char *) "self",(char *) "shortDesc", NULL
16405 };
16406
16407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) SWIG_fail;
16408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16409 if (!SWIG_IsOK(res1)) {
16410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_SetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo *""'");
16411 }
16412 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16413 {
16414 arg2 = wxString_in_helper(obj1);
16415 if (arg2 == NULL) SWIG_fail;
16416 temp2 = true;
16417 }
16418 {
16419 PyThreadState* __tstate = wxPyBeginAllowThreads();
16420 (arg1)->SetShortDesc((wxString const &)*arg2);
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 resultobj = SWIG_Py_Void();
16425 {
16426 if (temp2)
16427 delete arg2;
16428 }
16429 return resultobj;
16430 fail:
16431 {
16432 if (temp2)
16433 delete arg2;
16434 }
16435 return NULL;
16436 }
16437
16438
16439 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16440 PyObject *resultobj = 0;
16441 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16442 wxString *result = 0 ;
16443 void *argp1 = 0 ;
16444 int res1 = 0 ;
16445 PyObject *swig_obj[1] ;
16446
16447 if (!args) SWIG_fail;
16448 swig_obj[0] = args;
16449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16450 if (!SWIG_IsOK(res1)) {
16451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetMimeType" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16452 }
16453 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16454 {
16455 PyThreadState* __tstate = wxPyBeginAllowThreads();
16456 {
16457 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
16458 result = (wxString *) &_result_ref;
16459 }
16460 wxPyEndAllowThreads(__tstate);
16461 if (PyErr_Occurred()) SWIG_fail;
16462 }
16463 {
16464 #if wxUSE_UNICODE
16465 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16466 #else
16467 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16468 #endif
16469 }
16470 return resultobj;
16471 fail:
16472 return NULL;
16473 }
16474
16475
16476 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16477 PyObject *resultobj = 0;
16478 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16479 wxString *result = 0 ;
16480 void *argp1 = 0 ;
16481 int res1 = 0 ;
16482 PyObject *swig_obj[1] ;
16483
16484 if (!args) SWIG_fail;
16485 swig_obj[0] = args;
16486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16487 if (!SWIG_IsOK(res1)) {
16488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16489 }
16490 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16491 {
16492 PyThreadState* __tstate = wxPyBeginAllowThreads();
16493 {
16494 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
16495 result = (wxString *) &_result_ref;
16496 }
16497 wxPyEndAllowThreads(__tstate);
16498 if (PyErr_Occurred()) SWIG_fail;
16499 }
16500 {
16501 #if wxUSE_UNICODE
16502 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16503 #else
16504 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16505 #endif
16506 }
16507 return resultobj;
16508 fail:
16509 return NULL;
16510 }
16511
16512
16513 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16514 PyObject *resultobj = 0;
16515 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16516 wxString *result = 0 ;
16517 void *argp1 = 0 ;
16518 int res1 = 0 ;
16519 PyObject *swig_obj[1] ;
16520
16521 if (!args) SWIG_fail;
16522 swig_obj[0] = args;
16523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16524 if (!SWIG_IsOK(res1)) {
16525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16526 }
16527 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16528 {
16529 PyThreadState* __tstate = wxPyBeginAllowThreads();
16530 {
16531 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
16532 result = (wxString *) &_result_ref;
16533 }
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 {
16538 #if wxUSE_UNICODE
16539 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16540 #else
16541 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16542 #endif
16543 }
16544 return resultobj;
16545 fail:
16546 return NULL;
16547 }
16548
16549
16550 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16551 PyObject *resultobj = 0;
16552 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16553 wxString *result = 0 ;
16554 void *argp1 = 0 ;
16555 int res1 = 0 ;
16556 PyObject *swig_obj[1] ;
16557
16558 if (!args) SWIG_fail;
16559 swig_obj[0] = args;
16560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16561 if (!SWIG_IsOK(res1)) {
16562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetShortDesc" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16563 }
16564 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16565 {
16566 PyThreadState* __tstate = wxPyBeginAllowThreads();
16567 {
16568 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
16569 result = (wxString *) &_result_ref;
16570 }
16571 wxPyEndAllowThreads(__tstate);
16572 if (PyErr_Occurred()) SWIG_fail;
16573 }
16574 {
16575 #if wxUSE_UNICODE
16576 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16577 #else
16578 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16579 #endif
16580 }
16581 return resultobj;
16582 fail:
16583 return NULL;
16584 }
16585
16586
16587 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16588 PyObject *resultobj = 0;
16589 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16590 wxString *result = 0 ;
16591 void *argp1 = 0 ;
16592 int res1 = 0 ;
16593 PyObject *swig_obj[1] ;
16594
16595 if (!args) SWIG_fail;
16596 swig_obj[0] = args;
16597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16598 if (!SWIG_IsOK(res1)) {
16599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetDescription" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16600 }
16601 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 {
16605 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
16606 result = (wxString *) &_result_ref;
16607 }
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 {
16612 #if wxUSE_UNICODE
16613 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16614 #else
16615 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16616 #endif
16617 }
16618 return resultobj;
16619 fail:
16620 return NULL;
16621 }
16622
16623
16624 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16625 PyObject *resultobj = 0;
16626 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16627 wxArrayString *result = 0 ;
16628 void *argp1 = 0 ;
16629 int res1 = 0 ;
16630 PyObject *swig_obj[1] ;
16631
16632 if (!args) SWIG_fail;
16633 swig_obj[0] = args;
16634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16635 if (!SWIG_IsOK(res1)) {
16636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensions" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16637 }
16638 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 {
16642 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
16643 result = (wxArrayString *) &_result_ref;
16644 }
16645 wxPyEndAllowThreads(__tstate);
16646 if (PyErr_Occurred()) SWIG_fail;
16647 }
16648 {
16649 resultobj = wxArrayString2PyList_helper(*result);
16650 }
16651 return resultobj;
16652 fail:
16653 return NULL;
16654 }
16655
16656
16657 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16658 PyObject *resultobj = 0;
16659 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16660 size_t result;
16661 void *argp1 = 0 ;
16662 int res1 = 0 ;
16663 PyObject *swig_obj[1] ;
16664
16665 if (!args) SWIG_fail;
16666 swig_obj[0] = args;
16667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16668 if (!SWIG_IsOK(res1)) {
16669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetExtensionsCount" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16670 }
16671 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = (size_t)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16686 PyObject *resultobj = 0;
16687 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16688 wxString *result = 0 ;
16689 void *argp1 = 0 ;
16690 int res1 = 0 ;
16691 PyObject *swig_obj[1] ;
16692
16693 if (!args) SWIG_fail;
16694 swig_obj[0] = args;
16695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16696 if (!SWIG_IsOK(res1)) {
16697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconFile" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16698 }
16699 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 {
16703 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
16704 result = (wxString *) &_result_ref;
16705 }
16706 wxPyEndAllowThreads(__tstate);
16707 if (PyErr_Occurred()) SWIG_fail;
16708 }
16709 {
16710 #if wxUSE_UNICODE
16711 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16712 #else
16713 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16714 #endif
16715 }
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16723 PyObject *resultobj = 0;
16724 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
16725 int result;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 PyObject *swig_obj[1] ;
16729
16730 if (!args) SWIG_fail;
16731 swig_obj[0] = args;
16732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileTypeInfo, 0 | 0 );
16733 if (!SWIG_IsOK(res1)) {
16734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileTypeInfo_GetIconIndex" "', expected argument " "1"" of type '" "wxFileTypeInfo const *""'");
16735 }
16736 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16737 {
16738 PyThreadState* __tstate = wxPyBeginAllowThreads();
16739 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
16740 wxPyEndAllowThreads(__tstate);
16741 if (PyErr_Occurred()) SWIG_fail;
16742 }
16743 resultobj = SWIG_From_int(static_cast< int >(result));
16744 return resultobj;
16745 fail:
16746 return NULL;
16747 }
16748
16749
16750 SWIGINTERN PyObject *FileTypeInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16751 PyObject *obj;
16752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16753 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileTypeInfo, SWIG_NewClientData(obj));
16754 return SWIG_Py_Void();
16755 }
16756
16757 SWIGINTERN PyObject *FileTypeInfo_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16758 return SWIG_Python_InitShadowInstance(args);
16759 }
16760
16761 SWIGINTERN PyObject *_wrap_new_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16762 PyObject *resultobj = 0;
16763 wxFileTypeInfo *arg1 = 0 ;
16764 wxFileType *result = 0 ;
16765 void *argp1 = 0 ;
16766 int res1 = 0 ;
16767 PyObject * obj0 = 0 ;
16768 char * kwnames[] = {
16769 (char *) "ftInfo", NULL
16770 };
16771
16772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) SWIG_fail;
16773 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
16774 if (!SWIG_IsOK(res1)) {
16775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16776 }
16777 if (!argp1) {
16778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FileType" "', expected argument " "1"" of type '" "wxFileTypeInfo const &""'");
16779 }
16780 arg1 = reinterpret_cast< wxFileTypeInfo * >(argp1);
16781 {
16782 PyThreadState* __tstate = wxPyBeginAllowThreads();
16783 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
16784 wxPyEndAllowThreads(__tstate);
16785 if (PyErr_Occurred()) SWIG_fail;
16786 }
16787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_NEW | 0 );
16788 return resultobj;
16789 fail:
16790 return NULL;
16791 }
16792
16793
16794 SWIGINTERN PyObject *_wrap_delete_FileType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16795 PyObject *resultobj = 0;
16796 wxFileType *arg1 = (wxFileType *) 0 ;
16797 void *argp1 = 0 ;
16798 int res1 = 0 ;
16799 PyObject *swig_obj[1] ;
16800
16801 if (!args) SWIG_fail;
16802 swig_obj[0] = args;
16803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, SWIG_POINTER_DISOWN | 0 );
16804 if (!SWIG_IsOK(res1)) {
16805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileType" "', expected argument " "1"" of type '" "wxFileType *""'");
16806 }
16807 arg1 = reinterpret_cast< wxFileType * >(argp1);
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 delete arg1;
16811
16812 wxPyEndAllowThreads(__tstate);
16813 if (PyErr_Occurred()) SWIG_fail;
16814 }
16815 resultobj = SWIG_Py_Void();
16816 return resultobj;
16817 fail:
16818 return NULL;
16819 }
16820
16821
16822 SWIGINTERN PyObject *_wrap_FileType_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16823 PyObject *resultobj = 0;
16824 wxFileType *arg1 = (wxFileType *) 0 ;
16825 PyObject *result = 0 ;
16826 void *argp1 = 0 ;
16827 int res1 = 0 ;
16828 PyObject *swig_obj[1] ;
16829
16830 if (!args) SWIG_fail;
16831 swig_obj[0] = args;
16832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeType" "', expected argument " "1"" of type '" "wxFileType *""'");
16835 }
16836 arg1 = reinterpret_cast< wxFileType * >(argp1);
16837 {
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 result = (PyObject *)wxFileType_GetMimeType(arg1);
16840 wxPyEndAllowThreads(__tstate);
16841 if (PyErr_Occurred()) SWIG_fail;
16842 }
16843 resultobj = result;
16844 return resultobj;
16845 fail:
16846 return NULL;
16847 }
16848
16849
16850 SWIGINTERN PyObject *_wrap_FileType_GetMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16851 PyObject *resultobj = 0;
16852 wxFileType *arg1 = (wxFileType *) 0 ;
16853 PyObject *result = 0 ;
16854 void *argp1 = 0 ;
16855 int res1 = 0 ;
16856 PyObject *swig_obj[1] ;
16857
16858 if (!args) SWIG_fail;
16859 swig_obj[0] = args;
16860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16861 if (!SWIG_IsOK(res1)) {
16862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetMimeTypes" "', expected argument " "1"" of type '" "wxFileType *""'");
16863 }
16864 arg1 = reinterpret_cast< wxFileType * >(argp1);
16865 {
16866 PyThreadState* __tstate = wxPyBeginAllowThreads();
16867 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 resultobj = result;
16872 return resultobj;
16873 fail:
16874 return NULL;
16875 }
16876
16877
16878 SWIGINTERN PyObject *_wrap_FileType_GetExtensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16879 PyObject *resultobj = 0;
16880 wxFileType *arg1 = (wxFileType *) 0 ;
16881 PyObject *result = 0 ;
16882 void *argp1 = 0 ;
16883 int res1 = 0 ;
16884 PyObject *swig_obj[1] ;
16885
16886 if (!args) SWIG_fail;
16887 swig_obj[0] = args;
16888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16889 if (!SWIG_IsOK(res1)) {
16890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetExtensions" "', expected argument " "1"" of type '" "wxFileType *""'");
16891 }
16892 arg1 = reinterpret_cast< wxFileType * >(argp1);
16893 {
16894 PyThreadState* __tstate = wxPyBeginAllowThreads();
16895 result = (PyObject *)wxFileType_GetExtensions(arg1);
16896 wxPyEndAllowThreads(__tstate);
16897 if (PyErr_Occurred()) SWIG_fail;
16898 }
16899 resultobj = result;
16900 return resultobj;
16901 fail:
16902 return NULL;
16903 }
16904
16905
16906 SWIGINTERN PyObject *_wrap_FileType_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16907 PyObject *resultobj = 0;
16908 wxFileType *arg1 = (wxFileType *) 0 ;
16909 wxIcon *result = 0 ;
16910 void *argp1 = 0 ;
16911 int res1 = 0 ;
16912 PyObject *swig_obj[1] ;
16913
16914 if (!args) SWIG_fail;
16915 swig_obj[0] = args;
16916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16917 if (!SWIG_IsOK(res1)) {
16918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
16919 }
16920 arg1 = reinterpret_cast< wxFileType * >(argp1);
16921 {
16922 PyThreadState* __tstate = wxPyBeginAllowThreads();
16923 result = (wxIcon *)wxFileType_GetIcon(arg1);
16924 wxPyEndAllowThreads(__tstate);
16925 if (PyErr_Occurred()) SWIG_fail;
16926 }
16927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
16928 return resultobj;
16929 fail:
16930 return NULL;
16931 }
16932
16933
16934 SWIGINTERN PyObject *_wrap_FileType_GetIconInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16935 PyObject *resultobj = 0;
16936 wxFileType *arg1 = (wxFileType *) 0 ;
16937 PyObject *result = 0 ;
16938 void *argp1 = 0 ;
16939 int res1 = 0 ;
16940 PyObject *swig_obj[1] ;
16941
16942 if (!args) SWIG_fail;
16943 swig_obj[0] = args;
16944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16945 if (!SWIG_IsOK(res1)) {
16946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetIconInfo" "', expected argument " "1"" of type '" "wxFileType *""'");
16947 }
16948 arg1 = reinterpret_cast< wxFileType * >(argp1);
16949 {
16950 PyThreadState* __tstate = wxPyBeginAllowThreads();
16951 result = (PyObject *)wxFileType_GetIconInfo(arg1);
16952 wxPyEndAllowThreads(__tstate);
16953 if (PyErr_Occurred()) SWIG_fail;
16954 }
16955 resultobj = result;
16956 return resultobj;
16957 fail:
16958 return NULL;
16959 }
16960
16961
16962 SWIGINTERN PyObject *_wrap_FileType_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16963 PyObject *resultobj = 0;
16964 wxFileType *arg1 = (wxFileType *) 0 ;
16965 PyObject *result = 0 ;
16966 void *argp1 = 0 ;
16967 int res1 = 0 ;
16968 PyObject *swig_obj[1] ;
16969
16970 if (!args) SWIG_fail;
16971 swig_obj[0] = args;
16972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
16973 if (!SWIG_IsOK(res1)) {
16974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetDescription" "', expected argument " "1"" of type '" "wxFileType *""'");
16975 }
16976 arg1 = reinterpret_cast< wxFileType * >(argp1);
16977 {
16978 PyThreadState* __tstate = wxPyBeginAllowThreads();
16979 result = (PyObject *)wxFileType_GetDescription(arg1);
16980 wxPyEndAllowThreads(__tstate);
16981 if (PyErr_Occurred()) SWIG_fail;
16982 }
16983 resultobj = result;
16984 return resultobj;
16985 fail:
16986 return NULL;
16987 }
16988
16989
16990 SWIGINTERN PyObject *_wrap_FileType_GetOpenCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj = 0;
16992 wxFileType *arg1 = (wxFileType *) 0 ;
16993 wxString *arg2 = 0 ;
16994 wxString const &arg3_defvalue = wxPyEmptyString ;
16995 wxString *arg3 = (wxString *) &arg3_defvalue ;
16996 PyObject *result = 0 ;
16997 void *argp1 = 0 ;
16998 int res1 = 0 ;
16999 bool temp2 = false ;
17000 bool temp3 = false ;
17001 PyObject * obj0 = 0 ;
17002 PyObject * obj1 = 0 ;
17003 PyObject * obj2 = 0 ;
17004 char * kwnames[] = {
17005 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17006 };
17007
17008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17010 if (!SWIG_IsOK(res1)) {
17011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetOpenCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17012 }
17013 arg1 = reinterpret_cast< wxFileType * >(argp1);
17014 {
17015 arg2 = wxString_in_helper(obj1);
17016 if (arg2 == NULL) SWIG_fail;
17017 temp2 = true;
17018 }
17019 if (obj2) {
17020 {
17021 arg3 = wxString_in_helper(obj2);
17022 if (arg3 == NULL) SWIG_fail;
17023 temp3 = true;
17024 }
17025 }
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17029 wxPyEndAllowThreads(__tstate);
17030 if (PyErr_Occurred()) SWIG_fail;
17031 }
17032 resultobj = result;
17033 {
17034 if (temp2)
17035 delete arg2;
17036 }
17037 {
17038 if (temp3)
17039 delete arg3;
17040 }
17041 return resultobj;
17042 fail:
17043 {
17044 if (temp2)
17045 delete arg2;
17046 }
17047 {
17048 if (temp3)
17049 delete arg3;
17050 }
17051 return NULL;
17052 }
17053
17054
17055 SWIGINTERN PyObject *_wrap_FileType_GetPrintCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17056 PyObject *resultobj = 0;
17057 wxFileType *arg1 = (wxFileType *) 0 ;
17058 wxString *arg2 = 0 ;
17059 wxString const &arg3_defvalue = wxPyEmptyString ;
17060 wxString *arg3 = (wxString *) &arg3_defvalue ;
17061 PyObject *result = 0 ;
17062 void *argp1 = 0 ;
17063 int res1 = 0 ;
17064 bool temp2 = false ;
17065 bool temp3 = false ;
17066 PyObject * obj0 = 0 ;
17067 PyObject * obj1 = 0 ;
17068 PyObject * obj2 = 0 ;
17069 char * kwnames[] = {
17070 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17071 };
17072
17073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17075 if (!SWIG_IsOK(res1)) {
17076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetPrintCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17077 }
17078 arg1 = reinterpret_cast< wxFileType * >(argp1);
17079 {
17080 arg2 = wxString_in_helper(obj1);
17081 if (arg2 == NULL) SWIG_fail;
17082 temp2 = true;
17083 }
17084 if (obj2) {
17085 {
17086 arg3 = wxString_in_helper(obj2);
17087 if (arg3 == NULL) SWIG_fail;
17088 temp3 = true;
17089 }
17090 }
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 resultobj = result;
17098 {
17099 if (temp2)
17100 delete arg2;
17101 }
17102 {
17103 if (temp3)
17104 delete arg3;
17105 }
17106 return resultobj;
17107 fail:
17108 {
17109 if (temp2)
17110 delete arg2;
17111 }
17112 {
17113 if (temp3)
17114 delete arg3;
17115 }
17116 return NULL;
17117 }
17118
17119
17120 SWIGINTERN PyObject *_wrap_FileType_GetAllCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17121 PyObject *resultobj = 0;
17122 wxFileType *arg1 = (wxFileType *) 0 ;
17123 wxString *arg2 = 0 ;
17124 wxString const &arg3_defvalue = wxPyEmptyString ;
17125 wxString *arg3 = (wxString *) &arg3_defvalue ;
17126 PyObject *result = 0 ;
17127 void *argp1 = 0 ;
17128 int res1 = 0 ;
17129 bool temp2 = false ;
17130 bool temp3 = false ;
17131 PyObject * obj0 = 0 ;
17132 PyObject * obj1 = 0 ;
17133 PyObject * obj2 = 0 ;
17134 char * kwnames[] = {
17135 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
17136 };
17137
17138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17140 if (!SWIG_IsOK(res1)) {
17141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_GetAllCommands" "', expected argument " "1"" of type '" "wxFileType *""'");
17142 }
17143 arg1 = reinterpret_cast< wxFileType * >(argp1);
17144 {
17145 arg2 = wxString_in_helper(obj1);
17146 if (arg2 == NULL) SWIG_fail;
17147 temp2 = true;
17148 }
17149 if (obj2) {
17150 {
17151 arg3 = wxString_in_helper(obj2);
17152 if (arg3 == NULL) SWIG_fail;
17153 temp3 = true;
17154 }
17155 }
17156 {
17157 PyThreadState* __tstate = wxPyBeginAllowThreads();
17158 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17159 wxPyEndAllowThreads(__tstate);
17160 if (PyErr_Occurred()) SWIG_fail;
17161 }
17162 resultobj = result;
17163 {
17164 if (temp2)
17165 delete arg2;
17166 }
17167 {
17168 if (temp3)
17169 delete arg3;
17170 }
17171 return resultobj;
17172 fail:
17173 {
17174 if (temp2)
17175 delete arg2;
17176 }
17177 {
17178 if (temp3)
17179 delete arg3;
17180 }
17181 return NULL;
17182 }
17183
17184
17185 SWIGINTERN PyObject *_wrap_FileType_SetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17186 PyObject *resultobj = 0;
17187 wxFileType *arg1 = (wxFileType *) 0 ;
17188 wxString *arg2 = 0 ;
17189 wxString *arg3 = 0 ;
17190 bool arg4 = (bool) true ;
17191 bool result;
17192 void *argp1 = 0 ;
17193 int res1 = 0 ;
17194 bool temp2 = false ;
17195 bool temp3 = false ;
17196 bool val4 ;
17197 int ecode4 = 0 ;
17198 PyObject * obj0 = 0 ;
17199 PyObject * obj1 = 0 ;
17200 PyObject * obj2 = 0 ;
17201 PyObject * obj3 = 0 ;
17202 char * kwnames[] = {
17203 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
17204 };
17205
17206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17208 if (!SWIG_IsOK(res1)) {
17209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetCommand" "', expected argument " "1"" of type '" "wxFileType *""'");
17210 }
17211 arg1 = reinterpret_cast< wxFileType * >(argp1);
17212 {
17213 arg2 = wxString_in_helper(obj1);
17214 if (arg2 == NULL) SWIG_fail;
17215 temp2 = true;
17216 }
17217 {
17218 arg3 = wxString_in_helper(obj2);
17219 if (arg3 == NULL) SWIG_fail;
17220 temp3 = true;
17221 }
17222 if (obj3) {
17223 ecode4 = SWIG_AsVal_bool(obj3, &val4);
17224 if (!SWIG_IsOK(ecode4)) {
17225 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileType_SetCommand" "', expected argument " "4"" of type '" "bool""'");
17226 }
17227 arg4 = static_cast< bool >(val4);
17228 }
17229 {
17230 PyThreadState* __tstate = wxPyBeginAllowThreads();
17231 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17232 wxPyEndAllowThreads(__tstate);
17233 if (PyErr_Occurred()) SWIG_fail;
17234 }
17235 {
17236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17237 }
17238 {
17239 if (temp2)
17240 delete arg2;
17241 }
17242 {
17243 if (temp3)
17244 delete arg3;
17245 }
17246 return resultobj;
17247 fail:
17248 {
17249 if (temp2)
17250 delete arg2;
17251 }
17252 {
17253 if (temp3)
17254 delete arg3;
17255 }
17256 return NULL;
17257 }
17258
17259
17260 SWIGINTERN PyObject *_wrap_FileType_SetDefaultIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17261 PyObject *resultobj = 0;
17262 wxFileType *arg1 = (wxFileType *) 0 ;
17263 wxString const &arg2_defvalue = wxPyEmptyString ;
17264 wxString *arg2 = (wxString *) &arg2_defvalue ;
17265 int arg3 = (int) 0 ;
17266 bool result;
17267 void *argp1 = 0 ;
17268 int res1 = 0 ;
17269 bool temp2 = false ;
17270 int val3 ;
17271 int ecode3 = 0 ;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 PyObject * obj2 = 0 ;
17275 char * kwnames[] = {
17276 (char *) "self",(char *) "cmd",(char *) "index", NULL
17277 };
17278
17279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17281 if (!SWIG_IsOK(res1)) {
17282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_SetDefaultIcon" "', expected argument " "1"" of type '" "wxFileType *""'");
17283 }
17284 arg1 = reinterpret_cast< wxFileType * >(argp1);
17285 if (obj1) {
17286 {
17287 arg2 = wxString_in_helper(obj1);
17288 if (arg2 == NULL) SWIG_fail;
17289 temp2 = true;
17290 }
17291 }
17292 if (obj2) {
17293 ecode3 = SWIG_AsVal_int(obj2, &val3);
17294 if (!SWIG_IsOK(ecode3)) {
17295 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileType_SetDefaultIcon" "', expected argument " "3"" of type '" "int""'");
17296 }
17297 arg3 = static_cast< int >(val3);
17298 }
17299 {
17300 PyThreadState* __tstate = wxPyBeginAllowThreads();
17301 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 {
17306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17307 }
17308 {
17309 if (temp2)
17310 delete arg2;
17311 }
17312 return resultobj;
17313 fail:
17314 {
17315 if (temp2)
17316 delete arg2;
17317 }
17318 return NULL;
17319 }
17320
17321
17322 SWIGINTERN PyObject *_wrap_FileType_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 PyObject *resultobj = 0;
17324 wxFileType *arg1 = (wxFileType *) 0 ;
17325 bool result;
17326 void *argp1 = 0 ;
17327 int res1 = 0 ;
17328 PyObject *swig_obj[1] ;
17329
17330 if (!args) SWIG_fail;
17331 swig_obj[0] = args;
17332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileType, 0 | 0 );
17333 if (!SWIG_IsOK(res1)) {
17334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileType_Unassociate" "', expected argument " "1"" of type '" "wxFileType *""'");
17335 }
17336 arg1 = reinterpret_cast< wxFileType * >(argp1);
17337 {
17338 PyThreadState* __tstate = wxPyBeginAllowThreads();
17339 result = (bool)(arg1)->Unassociate();
17340 wxPyEndAllowThreads(__tstate);
17341 if (PyErr_Occurred()) SWIG_fail;
17342 }
17343 {
17344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17345 }
17346 return resultobj;
17347 fail:
17348 return NULL;
17349 }
17350
17351
17352 SWIGINTERN PyObject *_wrap_FileType_ExpandCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17353 PyObject *resultobj = 0;
17354 wxString *arg1 = 0 ;
17355 wxString *arg2 = 0 ;
17356 wxString const &arg3_defvalue = wxPyEmptyString ;
17357 wxString *arg3 = (wxString *) &arg3_defvalue ;
17358 wxString result;
17359 bool temp1 = false ;
17360 bool temp2 = false ;
17361 bool temp3 = false ;
17362 PyObject * obj0 = 0 ;
17363 PyObject * obj1 = 0 ;
17364 PyObject * obj2 = 0 ;
17365 char * kwnames[] = {
17366 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
17367 };
17368
17369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17370 {
17371 arg1 = wxString_in_helper(obj0);
17372 if (arg1 == NULL) SWIG_fail;
17373 temp1 = true;
17374 }
17375 {
17376 arg2 = wxString_in_helper(obj1);
17377 if (arg2 == NULL) SWIG_fail;
17378 temp2 = true;
17379 }
17380 if (obj2) {
17381 {
17382 arg3 = wxString_in_helper(obj2);
17383 if (arg3 == NULL) SWIG_fail;
17384 temp3 = true;
17385 }
17386 }
17387 {
17388 PyThreadState* __tstate = wxPyBeginAllowThreads();
17389 result = wxFileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
17390 wxPyEndAllowThreads(__tstate);
17391 if (PyErr_Occurred()) SWIG_fail;
17392 }
17393 {
17394 #if wxUSE_UNICODE
17395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17396 #else
17397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17398 #endif
17399 }
17400 {
17401 if (temp1)
17402 delete arg1;
17403 }
17404 {
17405 if (temp2)
17406 delete arg2;
17407 }
17408 {
17409 if (temp3)
17410 delete arg3;
17411 }
17412 return resultobj;
17413 fail:
17414 {
17415 if (temp1)
17416 delete arg1;
17417 }
17418 {
17419 if (temp2)
17420 delete arg2;
17421 }
17422 {
17423 if (temp3)
17424 delete arg3;
17425 }
17426 return NULL;
17427 }
17428
17429
17430 SWIGINTERN PyObject *FileType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17431 PyObject *obj;
17432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17433 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileType, SWIG_NewClientData(obj));
17434 return SWIG_Py_Void();
17435 }
17436
17437 SWIGINTERN PyObject *FileType_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17438 return SWIG_Python_InitShadowInstance(args);
17439 }
17440
17441 SWIGINTERN int TheMimeTypesManager_set(PyObject *) {
17442 SWIG_Error(SWIG_AttributeError,"Variable TheMimeTypesManager is read-only.");
17443 return 1;
17444 }
17445
17446
17447 SWIGINTERN PyObject *TheMimeTypesManager_get(void) {
17448 PyObject *pyobj = 0;
17449
17450 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0 );
17451 return pyobj;
17452 }
17453
17454
17455 SWIGINTERN PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17456 PyObject *resultobj = 0;
17457 wxString *arg1 = 0 ;
17458 wxString *arg2 = 0 ;
17459 bool result;
17460 bool temp1 = false ;
17461 bool temp2 = false ;
17462 PyObject * obj0 = 0 ;
17463 PyObject * obj1 = 0 ;
17464 char * kwnames[] = {
17465 (char *) "mimeType",(char *) "wildcard", NULL
17466 };
17467
17468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) SWIG_fail;
17469 {
17470 arg1 = wxString_in_helper(obj0);
17471 if (arg1 == NULL) SWIG_fail;
17472 temp1 = true;
17473 }
17474 {
17475 arg2 = wxString_in_helper(obj1);
17476 if (arg2 == NULL) SWIG_fail;
17477 temp2 = true;
17478 }
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 {
17486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17487 }
17488 {
17489 if (temp1)
17490 delete arg1;
17491 }
17492 {
17493 if (temp2)
17494 delete arg2;
17495 }
17496 return resultobj;
17497 fail:
17498 {
17499 if (temp1)
17500 delete arg1;
17501 }
17502 {
17503 if (temp2)
17504 delete arg2;
17505 }
17506 return NULL;
17507 }
17508
17509
17510 SWIGINTERN PyObject *_wrap_new_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17511 PyObject *resultobj = 0;
17512 wxMimeTypesManager *result = 0 ;
17513
17514 if (!SWIG_Python_UnpackTuple(args,"new_MimeTypesManager",0,0,0)) SWIG_fail;
17515 {
17516 PyThreadState* __tstate = wxPyBeginAllowThreads();
17517 result = (wxMimeTypesManager *)new wxMimeTypesManager();
17518 wxPyEndAllowThreads(__tstate);
17519 if (PyErr_Occurred()) SWIG_fail;
17520 }
17521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_NEW | 0 );
17522 return resultobj;
17523 fail:
17524 return NULL;
17525 }
17526
17527
17528 SWIGINTERN PyObject *_wrap_MimeTypesManager_Initialize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17529 PyObject *resultobj = 0;
17530 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17531 int arg2 = (int) wxMAILCAP_ALL ;
17532 wxString const &arg3_defvalue = wxPyEmptyString ;
17533 wxString *arg3 = (wxString *) &arg3_defvalue ;
17534 void *argp1 = 0 ;
17535 int res1 = 0 ;
17536 int val2 ;
17537 int ecode2 = 0 ;
17538 bool temp3 = false ;
17539 PyObject * obj0 = 0 ;
17540 PyObject * obj1 = 0 ;
17541 PyObject * obj2 = 0 ;
17542 char * kwnames[] = {
17543 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
17544 };
17545
17546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17548 if (!SWIG_IsOK(res1)) {
17549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Initialize" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17550 }
17551 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17552 if (obj1) {
17553 ecode2 = SWIG_AsVal_int(obj1, &val2);
17554 if (!SWIG_IsOK(ecode2)) {
17555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MimeTypesManager_Initialize" "', expected argument " "2"" of type '" "int""'");
17556 }
17557 arg2 = static_cast< int >(val2);
17558 }
17559 if (obj2) {
17560 {
17561 arg3 = wxString_in_helper(obj2);
17562 if (arg3 == NULL) SWIG_fail;
17563 temp3 = true;
17564 }
17565 }
17566 {
17567 PyThreadState* __tstate = wxPyBeginAllowThreads();
17568 (arg1)->Initialize(arg2,(wxString const &)*arg3);
17569 wxPyEndAllowThreads(__tstate);
17570 if (PyErr_Occurred()) SWIG_fail;
17571 }
17572 resultobj = SWIG_Py_Void();
17573 {
17574 if (temp3)
17575 delete arg3;
17576 }
17577 return resultobj;
17578 fail:
17579 {
17580 if (temp3)
17581 delete arg3;
17582 }
17583 return NULL;
17584 }
17585
17586
17587 SWIGINTERN PyObject *_wrap_MimeTypesManager_ClearData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17588 PyObject *resultobj = 0;
17589 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17590 void *argp1 = 0 ;
17591 int res1 = 0 ;
17592 PyObject *swig_obj[1] ;
17593
17594 if (!args) SWIG_fail;
17595 swig_obj[0] = args;
17596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17597 if (!SWIG_IsOK(res1)) {
17598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ClearData" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17599 }
17600 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17601 {
17602 PyThreadState* __tstate = wxPyBeginAllowThreads();
17603 (arg1)->ClearData();
17604 wxPyEndAllowThreads(__tstate);
17605 if (PyErr_Occurred()) SWIG_fail;
17606 }
17607 resultobj = SWIG_Py_Void();
17608 return resultobj;
17609 fail:
17610 return NULL;
17611 }
17612
17613
17614 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17615 PyObject *resultobj = 0;
17616 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17617 wxString *arg2 = 0 ;
17618 wxFileType *result = 0 ;
17619 void *argp1 = 0 ;
17620 int res1 = 0 ;
17621 bool temp2 = false ;
17622 PyObject * obj0 = 0 ;
17623 PyObject * obj1 = 0 ;
17624 char * kwnames[] = {
17625 (char *) "self",(char *) "ext", NULL
17626 };
17627
17628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) SWIG_fail;
17629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17630 if (!SWIG_IsOK(res1)) {
17631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromExtension" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17632 }
17633 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17634 {
17635 arg2 = wxString_in_helper(obj1);
17636 if (arg2 == NULL) SWIG_fail;
17637 temp2 = true;
17638 }
17639 {
17640 PyThreadState* __tstate = wxPyBeginAllowThreads();
17641 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
17642 wxPyEndAllowThreads(__tstate);
17643 if (PyErr_Occurred()) SWIG_fail;
17644 }
17645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17646 {
17647 if (temp2)
17648 delete arg2;
17649 }
17650 return resultobj;
17651 fail:
17652 {
17653 if (temp2)
17654 delete arg2;
17655 }
17656 return NULL;
17657 }
17658
17659
17660 SWIGINTERN PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17661 PyObject *resultobj = 0;
17662 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17663 wxString *arg2 = 0 ;
17664 wxFileType *result = 0 ;
17665 void *argp1 = 0 ;
17666 int res1 = 0 ;
17667 bool temp2 = false ;
17668 PyObject * obj0 = 0 ;
17669 PyObject * obj1 = 0 ;
17670 char * kwnames[] = {
17671 (char *) "self",(char *) "mimeType", NULL
17672 };
17673
17674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
17675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17676 if (!SWIG_IsOK(res1)) {
17677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_GetFileTypeFromMimeType" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17678 }
17679 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17680 {
17681 arg2 = wxString_in_helper(obj1);
17682 if (arg2 == NULL) SWIG_fail;
17683 temp2 = true;
17684 }
17685 {
17686 PyThreadState* __tstate = wxPyBeginAllowThreads();
17687 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
17688 wxPyEndAllowThreads(__tstate);
17689 if (PyErr_Occurred()) SWIG_fail;
17690 }
17691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17692 {
17693 if (temp2)
17694 delete arg2;
17695 }
17696 return resultobj;
17697 fail:
17698 {
17699 if (temp2)
17700 delete arg2;
17701 }
17702 return NULL;
17703 }
17704
17705
17706 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17707 PyObject *resultobj = 0;
17708 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17709 wxString *arg2 = 0 ;
17710 bool arg3 = (bool) false ;
17711 bool result;
17712 void *argp1 = 0 ;
17713 int res1 = 0 ;
17714 bool temp2 = false ;
17715 bool val3 ;
17716 int ecode3 = 0 ;
17717 PyObject * obj0 = 0 ;
17718 PyObject * obj1 = 0 ;
17719 PyObject * obj2 = 0 ;
17720 char * kwnames[] = {
17721 (char *) "self",(char *) "filename",(char *) "fallback", NULL
17722 };
17723
17724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17726 if (!SWIG_IsOK(res1)) {
17727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17728 }
17729 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17730 {
17731 arg2 = wxString_in_helper(obj1);
17732 if (arg2 == NULL) SWIG_fail;
17733 temp2 = true;
17734 }
17735 if (obj2) {
17736 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17737 if (!SWIG_IsOK(ecode3)) {
17738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MimeTypesManager_ReadMailcap" "', expected argument " "3"" of type '" "bool""'");
17739 }
17740 arg3 = static_cast< bool >(val3);
17741 }
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
17745 wxPyEndAllowThreads(__tstate);
17746 if (PyErr_Occurred()) SWIG_fail;
17747 }
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 {
17752 if (temp2)
17753 delete arg2;
17754 }
17755 return resultobj;
17756 fail:
17757 {
17758 if (temp2)
17759 delete arg2;
17760 }
17761 return NULL;
17762 }
17763
17764
17765 SWIGINTERN PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj = 0;
17767 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17768 wxString *arg2 = 0 ;
17769 bool result;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 bool temp2 = false ;
17773 PyObject * obj0 = 0 ;
17774 PyObject * obj1 = 0 ;
17775 char * kwnames[] = {
17776 (char *) "self",(char *) "filename", NULL
17777 };
17778
17779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) SWIG_fail;
17780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17781 if (!SWIG_IsOK(res1)) {
17782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_ReadMimeTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17783 }
17784 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17785 {
17786 arg2 = wxString_in_helper(obj1);
17787 if (arg2 == NULL) SWIG_fail;
17788 temp2 = true;
17789 }
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
17793 wxPyEndAllowThreads(__tstate);
17794 if (PyErr_Occurred()) SWIG_fail;
17795 }
17796 {
17797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17798 }
17799 {
17800 if (temp2)
17801 delete arg2;
17802 }
17803 return resultobj;
17804 fail:
17805 {
17806 if (temp2)
17807 delete arg2;
17808 }
17809 return NULL;
17810 }
17811
17812
17813 SWIGINTERN PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17814 PyObject *resultobj = 0;
17815 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17816 PyObject *result = 0 ;
17817 void *argp1 = 0 ;
17818 int res1 = 0 ;
17819 PyObject *swig_obj[1] ;
17820
17821 if (!args) SWIG_fail;
17822 swig_obj[0] = args;
17823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17824 if (!SWIG_IsOK(res1)) {
17825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_EnumAllFileTypes" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17826 }
17827 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17828 {
17829 PyThreadState* __tstate = wxPyBeginAllowThreads();
17830 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
17831 wxPyEndAllowThreads(__tstate);
17832 if (PyErr_Occurred()) SWIG_fail;
17833 }
17834 resultobj = result;
17835 return resultobj;
17836 fail:
17837 return NULL;
17838 }
17839
17840
17841 SWIGINTERN PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17842 PyObject *resultobj = 0;
17843 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17844 wxFileTypeInfo *arg2 = 0 ;
17845 void *argp1 = 0 ;
17846 int res1 = 0 ;
17847 void *argp2 = 0 ;
17848 int res2 = 0 ;
17849 PyObject * obj0 = 0 ;
17850 PyObject * obj1 = 0 ;
17851 char * kwnames[] = {
17852 (char *) "self",(char *) "ft", NULL
17853 };
17854
17855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) SWIG_fail;
17856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17857 if (!SWIG_IsOK(res1)) {
17858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17859 }
17860 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17861 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17862 if (!SWIG_IsOK(res2)) {
17863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17864 }
17865 if (!argp2) {
17866 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_AddFallback" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17867 }
17868 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17869 {
17870 PyThreadState* __tstate = wxPyBeginAllowThreads();
17871 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
17872 wxPyEndAllowThreads(__tstate);
17873 if (PyErr_Occurred()) SWIG_fail;
17874 }
17875 resultobj = SWIG_Py_Void();
17876 return resultobj;
17877 fail:
17878 return NULL;
17879 }
17880
17881
17882 SWIGINTERN PyObject *_wrap_MimeTypesManager_Associate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17883 PyObject *resultobj = 0;
17884 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17885 wxFileTypeInfo *arg2 = 0 ;
17886 wxFileType *result = 0 ;
17887 void *argp1 = 0 ;
17888 int res1 = 0 ;
17889 void *argp2 = 0 ;
17890 int res2 = 0 ;
17891 PyObject * obj0 = 0 ;
17892 PyObject * obj1 = 0 ;
17893 char * kwnames[] = {
17894 (char *) "self",(char *) "ftInfo", NULL
17895 };
17896
17897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) SWIG_fail;
17898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17899 if (!SWIG_IsOK(res1)) {
17900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Associate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17901 }
17902 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17903 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileTypeInfo, 0 | 0);
17904 if (!SWIG_IsOK(res2)) {
17905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17906 }
17907 if (!argp2) {
17908 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MimeTypesManager_Associate" "', expected argument " "2"" of type '" "wxFileTypeInfo const &""'");
17909 }
17910 arg2 = reinterpret_cast< wxFileTypeInfo * >(argp2);
17911 {
17912 PyThreadState* __tstate = wxPyBeginAllowThreads();
17913 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
17914 wxPyEndAllowThreads(__tstate);
17915 if (PyErr_Occurred()) SWIG_fail;
17916 }
17917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileType, SWIG_POINTER_OWN | 0 );
17918 return resultobj;
17919 fail:
17920 return NULL;
17921 }
17922
17923
17924 SWIGINTERN PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17925 PyObject *resultobj = 0;
17926 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17927 wxFileType *arg2 = (wxFileType *) 0 ;
17928 bool result;
17929 void *argp1 = 0 ;
17930 int res1 = 0 ;
17931 void *argp2 = 0 ;
17932 int res2 = 0 ;
17933 PyObject * obj0 = 0 ;
17934 PyObject * obj1 = 0 ;
17935 char * kwnames[] = {
17936 (char *) "self",(char *) "ft", NULL
17937 };
17938
17939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) SWIG_fail;
17940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMimeTypesManager, 0 | 0 );
17941 if (!SWIG_IsOK(res1)) {
17942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17943 }
17944 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17945 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFileType, 0 | 0 );
17946 if (!SWIG_IsOK(res2)) {
17947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MimeTypesManager_Unassociate" "', expected argument " "2"" of type '" "wxFileType *""'");
17948 }
17949 arg2 = reinterpret_cast< wxFileType * >(argp2);
17950 {
17951 PyThreadState* __tstate = wxPyBeginAllowThreads();
17952 result = (bool)(arg1)->Unassociate(arg2);
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 {
17957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17958 }
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *_wrap_delete_MimeTypesManager(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17966 PyObject *resultobj = 0;
17967 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
17968 void *argp1 = 0 ;
17969 int res1 = 0 ;
17970 PyObject *swig_obj[1] ;
17971
17972 if (!args) SWIG_fail;
17973 swig_obj[0] = args;
17974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_DISOWN | 0 );
17975 if (!SWIG_IsOK(res1)) {
17976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MimeTypesManager" "', expected argument " "1"" of type '" "wxMimeTypesManager *""'");
17977 }
17978 arg1 = reinterpret_cast< wxMimeTypesManager * >(argp1);
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 delete arg1;
17982
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 resultobj = SWIG_Py_Void();
17987 return resultobj;
17988 fail:
17989 return NULL;
17990 }
17991
17992
17993 SWIGINTERN PyObject *MimeTypesManager_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17994 PyObject *obj;
17995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17996 SWIG_TypeNewClientData(SWIGTYPE_p_wxMimeTypesManager, SWIG_NewClientData(obj));
17997 return SWIG_Py_Void();
17998 }
17999
18000 SWIGINTERN PyObject *MimeTypesManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18001 return SWIG_Python_InitShadowInstance(args);
18002 }
18003
18004 SWIGINTERN int ART_TOOLBAR_set(PyObject *) {
18005 SWIG_Error(SWIG_AttributeError,"Variable ART_TOOLBAR is read-only.");
18006 return 1;
18007 }
18008
18009
18010 SWIGINTERN PyObject *ART_TOOLBAR_get(void) {
18011 PyObject *pyobj = 0;
18012
18013 {
18014 #if wxUSE_UNICODE
18015 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18016 #else
18017 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
18018 #endif
18019 }
18020 return pyobj;
18021 }
18022
18023
18024 SWIGINTERN int ART_MENU_set(PyObject *) {
18025 SWIG_Error(SWIG_AttributeError,"Variable ART_MENU is read-only.");
18026 return 1;
18027 }
18028
18029
18030 SWIGINTERN PyObject *ART_MENU_get(void) {
18031 PyObject *pyobj = 0;
18032
18033 {
18034 #if wxUSE_UNICODE
18035 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18036 #else
18037 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
18038 #endif
18039 }
18040 return pyobj;
18041 }
18042
18043
18044 SWIGINTERN int ART_FRAME_ICON_set(PyObject *) {
18045 SWIG_Error(SWIG_AttributeError,"Variable ART_FRAME_ICON is read-only.");
18046 return 1;
18047 }
18048
18049
18050 SWIGINTERN PyObject *ART_FRAME_ICON_get(void) {
18051 PyObject *pyobj = 0;
18052
18053 {
18054 #if wxUSE_UNICODE
18055 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18056 #else
18057 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
18058 #endif
18059 }
18060 return pyobj;
18061 }
18062
18063
18064 SWIGINTERN int ART_CMN_DIALOG_set(PyObject *) {
18065 SWIG_Error(SWIG_AttributeError,"Variable ART_CMN_DIALOG is read-only.");
18066 return 1;
18067 }
18068
18069
18070 SWIGINTERN PyObject *ART_CMN_DIALOG_get(void) {
18071 PyObject *pyobj = 0;
18072
18073 {
18074 #if wxUSE_UNICODE
18075 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18076 #else
18077 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
18078 #endif
18079 }
18080 return pyobj;
18081 }
18082
18083
18084 SWIGINTERN int ART_HELP_BROWSER_set(PyObject *) {
18085 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BROWSER is read-only.");
18086 return 1;
18087 }
18088
18089
18090 SWIGINTERN PyObject *ART_HELP_BROWSER_get(void) {
18091 PyObject *pyobj = 0;
18092
18093 {
18094 #if wxUSE_UNICODE
18095 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18096 #else
18097 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
18098 #endif
18099 }
18100 return pyobj;
18101 }
18102
18103
18104 SWIGINTERN int ART_MESSAGE_BOX_set(PyObject *) {
18105 SWIG_Error(SWIG_AttributeError,"Variable ART_MESSAGE_BOX is read-only.");
18106 return 1;
18107 }
18108
18109
18110 SWIGINTERN PyObject *ART_MESSAGE_BOX_get(void) {
18111 PyObject *pyobj = 0;
18112
18113 {
18114 #if wxUSE_UNICODE
18115 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18116 #else
18117 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
18118 #endif
18119 }
18120 return pyobj;
18121 }
18122
18123
18124 SWIGINTERN int ART_BUTTON_set(PyObject *) {
18125 SWIG_Error(SWIG_AttributeError,"Variable ART_BUTTON is read-only.");
18126 return 1;
18127 }
18128
18129
18130 SWIGINTERN PyObject *ART_BUTTON_get(void) {
18131 PyObject *pyobj = 0;
18132
18133 {
18134 #if wxUSE_UNICODE
18135 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18136 #else
18137 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
18138 #endif
18139 }
18140 return pyobj;
18141 }
18142
18143
18144 SWIGINTERN int ART_OTHER_set(PyObject *) {
18145 SWIG_Error(SWIG_AttributeError,"Variable ART_OTHER is read-only.");
18146 return 1;
18147 }
18148
18149
18150 SWIGINTERN PyObject *ART_OTHER_get(void) {
18151 PyObject *pyobj = 0;
18152
18153 {
18154 #if wxUSE_UNICODE
18155 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18156 #else
18157 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
18158 #endif
18159 }
18160 return pyobj;
18161 }
18162
18163
18164 SWIGINTERN int ART_ADD_BOOKMARK_set(PyObject *) {
18165 SWIG_Error(SWIG_AttributeError,"Variable ART_ADD_BOOKMARK is read-only.");
18166 return 1;
18167 }
18168
18169
18170 SWIGINTERN PyObject *ART_ADD_BOOKMARK_get(void) {
18171 PyObject *pyobj = 0;
18172
18173 {
18174 #if wxUSE_UNICODE
18175 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18176 #else
18177 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
18178 #endif
18179 }
18180 return pyobj;
18181 }
18182
18183
18184 SWIGINTERN int ART_DEL_BOOKMARK_set(PyObject *) {
18185 SWIG_Error(SWIG_AttributeError,"Variable ART_DEL_BOOKMARK is read-only.");
18186 return 1;
18187 }
18188
18189
18190 SWIGINTERN PyObject *ART_DEL_BOOKMARK_get(void) {
18191 PyObject *pyobj = 0;
18192
18193 {
18194 #if wxUSE_UNICODE
18195 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18196 #else
18197 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
18198 #endif
18199 }
18200 return pyobj;
18201 }
18202
18203
18204 SWIGINTERN int ART_HELP_SIDE_PANEL_set(PyObject *) {
18205 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
18206 return 1;
18207 }
18208
18209
18210 SWIGINTERN PyObject *ART_HELP_SIDE_PANEL_get(void) {
18211 PyObject *pyobj = 0;
18212
18213 {
18214 #if wxUSE_UNICODE
18215 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18216 #else
18217 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
18218 #endif
18219 }
18220 return pyobj;
18221 }
18222
18223
18224 SWIGINTERN int ART_HELP_SETTINGS_set(PyObject *) {
18225 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_SETTINGS is read-only.");
18226 return 1;
18227 }
18228
18229
18230 SWIGINTERN PyObject *ART_HELP_SETTINGS_get(void) {
18231 PyObject *pyobj = 0;
18232
18233 {
18234 #if wxUSE_UNICODE
18235 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18236 #else
18237 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
18238 #endif
18239 }
18240 return pyobj;
18241 }
18242
18243
18244 SWIGINTERN int ART_HELP_BOOK_set(PyObject *) {
18245 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_BOOK is read-only.");
18246 return 1;
18247 }
18248
18249
18250 SWIGINTERN PyObject *ART_HELP_BOOK_get(void) {
18251 PyObject *pyobj = 0;
18252
18253 {
18254 #if wxUSE_UNICODE
18255 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18256 #else
18257 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
18258 #endif
18259 }
18260 return pyobj;
18261 }
18262
18263
18264 SWIGINTERN int ART_HELP_FOLDER_set(PyObject *) {
18265 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_FOLDER is read-only.");
18266 return 1;
18267 }
18268
18269
18270 SWIGINTERN PyObject *ART_HELP_FOLDER_get(void) {
18271 PyObject *pyobj = 0;
18272
18273 {
18274 #if wxUSE_UNICODE
18275 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18276 #else
18277 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
18278 #endif
18279 }
18280 return pyobj;
18281 }
18282
18283
18284 SWIGINTERN int ART_HELP_PAGE_set(PyObject *) {
18285 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP_PAGE is read-only.");
18286 return 1;
18287 }
18288
18289
18290 SWIGINTERN PyObject *ART_HELP_PAGE_get(void) {
18291 PyObject *pyobj = 0;
18292
18293 {
18294 #if wxUSE_UNICODE
18295 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18296 #else
18297 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
18298 #endif
18299 }
18300 return pyobj;
18301 }
18302
18303
18304 SWIGINTERN int ART_GO_BACK_set(PyObject *) {
18305 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_BACK is read-only.");
18306 return 1;
18307 }
18308
18309
18310 SWIGINTERN PyObject *ART_GO_BACK_get(void) {
18311 PyObject *pyobj = 0;
18312
18313 {
18314 #if wxUSE_UNICODE
18315 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18316 #else
18317 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
18318 #endif
18319 }
18320 return pyobj;
18321 }
18322
18323
18324 SWIGINTERN int ART_GO_FORWARD_set(PyObject *) {
18325 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_FORWARD is read-only.");
18326 return 1;
18327 }
18328
18329
18330 SWIGINTERN PyObject *ART_GO_FORWARD_get(void) {
18331 PyObject *pyobj = 0;
18332
18333 {
18334 #if wxUSE_UNICODE
18335 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18336 #else
18337 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
18338 #endif
18339 }
18340 return pyobj;
18341 }
18342
18343
18344 SWIGINTERN int ART_GO_UP_set(PyObject *) {
18345 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_UP is read-only.");
18346 return 1;
18347 }
18348
18349
18350 SWIGINTERN PyObject *ART_GO_UP_get(void) {
18351 PyObject *pyobj = 0;
18352
18353 {
18354 #if wxUSE_UNICODE
18355 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18356 #else
18357 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
18358 #endif
18359 }
18360 return pyobj;
18361 }
18362
18363
18364 SWIGINTERN int ART_GO_DOWN_set(PyObject *) {
18365 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DOWN is read-only.");
18366 return 1;
18367 }
18368
18369
18370 SWIGINTERN PyObject *ART_GO_DOWN_get(void) {
18371 PyObject *pyobj = 0;
18372
18373 {
18374 #if wxUSE_UNICODE
18375 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18376 #else
18377 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
18378 #endif
18379 }
18380 return pyobj;
18381 }
18382
18383
18384 SWIGINTERN int ART_GO_TO_PARENT_set(PyObject *) {
18385 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_TO_PARENT is read-only.");
18386 return 1;
18387 }
18388
18389
18390 SWIGINTERN PyObject *ART_GO_TO_PARENT_get(void) {
18391 PyObject *pyobj = 0;
18392
18393 {
18394 #if wxUSE_UNICODE
18395 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18396 #else
18397 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
18398 #endif
18399 }
18400 return pyobj;
18401 }
18402
18403
18404 SWIGINTERN int ART_GO_HOME_set(PyObject *) {
18405 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_HOME is read-only.");
18406 return 1;
18407 }
18408
18409
18410 SWIGINTERN PyObject *ART_GO_HOME_get(void) {
18411 PyObject *pyobj = 0;
18412
18413 {
18414 #if wxUSE_UNICODE
18415 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18416 #else
18417 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
18418 #endif
18419 }
18420 return pyobj;
18421 }
18422
18423
18424 SWIGINTERN int ART_FILE_OPEN_set(PyObject *) {
18425 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_OPEN is read-only.");
18426 return 1;
18427 }
18428
18429
18430 SWIGINTERN PyObject *ART_FILE_OPEN_get(void) {
18431 PyObject *pyobj = 0;
18432
18433 {
18434 #if wxUSE_UNICODE
18435 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18436 #else
18437 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
18438 #endif
18439 }
18440 return pyobj;
18441 }
18442
18443
18444 SWIGINTERN int ART_FILE_SAVE_set(PyObject *) {
18445 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE is read-only.");
18446 return 1;
18447 }
18448
18449
18450 SWIGINTERN PyObject *ART_FILE_SAVE_get(void) {
18451 PyObject *pyobj = 0;
18452
18453 {
18454 #if wxUSE_UNICODE
18455 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18456 #else
18457 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
18458 #endif
18459 }
18460 return pyobj;
18461 }
18462
18463
18464 SWIGINTERN int ART_FILE_SAVE_AS_set(PyObject *) {
18465 SWIG_Error(SWIG_AttributeError,"Variable ART_FILE_SAVE_AS is read-only.");
18466 return 1;
18467 }
18468
18469
18470 SWIGINTERN PyObject *ART_FILE_SAVE_AS_get(void) {
18471 PyObject *pyobj = 0;
18472
18473 {
18474 #if wxUSE_UNICODE
18475 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18476 #else
18477 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
18478 #endif
18479 }
18480 return pyobj;
18481 }
18482
18483
18484 SWIGINTERN int ART_PRINT_set(PyObject *) {
18485 SWIG_Error(SWIG_AttributeError,"Variable ART_PRINT is read-only.");
18486 return 1;
18487 }
18488
18489
18490 SWIGINTERN PyObject *ART_PRINT_get(void) {
18491 PyObject *pyobj = 0;
18492
18493 {
18494 #if wxUSE_UNICODE
18495 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18496 #else
18497 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
18498 #endif
18499 }
18500 return pyobj;
18501 }
18502
18503
18504 SWIGINTERN int ART_HELP_set(PyObject *) {
18505 SWIG_Error(SWIG_AttributeError,"Variable ART_HELP is read-only.");
18506 return 1;
18507 }
18508
18509
18510 SWIGINTERN PyObject *ART_HELP_get(void) {
18511 PyObject *pyobj = 0;
18512
18513 {
18514 #if wxUSE_UNICODE
18515 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18516 #else
18517 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
18518 #endif
18519 }
18520 return pyobj;
18521 }
18522
18523
18524 SWIGINTERN int ART_TIP_set(PyObject *) {
18525 SWIG_Error(SWIG_AttributeError,"Variable ART_TIP is read-only.");
18526 return 1;
18527 }
18528
18529
18530 SWIGINTERN PyObject *ART_TIP_get(void) {
18531 PyObject *pyobj = 0;
18532
18533 {
18534 #if wxUSE_UNICODE
18535 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18536 #else
18537 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
18538 #endif
18539 }
18540 return pyobj;
18541 }
18542
18543
18544 SWIGINTERN int ART_REPORT_VIEW_set(PyObject *) {
18545 SWIG_Error(SWIG_AttributeError,"Variable ART_REPORT_VIEW is read-only.");
18546 return 1;
18547 }
18548
18549
18550 SWIGINTERN PyObject *ART_REPORT_VIEW_get(void) {
18551 PyObject *pyobj = 0;
18552
18553 {
18554 #if wxUSE_UNICODE
18555 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18556 #else
18557 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
18558 #endif
18559 }
18560 return pyobj;
18561 }
18562
18563
18564 SWIGINTERN int ART_LIST_VIEW_set(PyObject *) {
18565 SWIG_Error(SWIG_AttributeError,"Variable ART_LIST_VIEW is read-only.");
18566 return 1;
18567 }
18568
18569
18570 SWIGINTERN PyObject *ART_LIST_VIEW_get(void) {
18571 PyObject *pyobj = 0;
18572
18573 {
18574 #if wxUSE_UNICODE
18575 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18576 #else
18577 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
18578 #endif
18579 }
18580 return pyobj;
18581 }
18582
18583
18584 SWIGINTERN int ART_NEW_DIR_set(PyObject *) {
18585 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW_DIR is read-only.");
18586 return 1;
18587 }
18588
18589
18590 SWIGINTERN PyObject *ART_NEW_DIR_get(void) {
18591 PyObject *pyobj = 0;
18592
18593 {
18594 #if wxUSE_UNICODE
18595 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18596 #else
18597 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
18598 #endif
18599 }
18600 return pyobj;
18601 }
18602
18603
18604 SWIGINTERN int ART_HARDDISK_set(PyObject *) {
18605 SWIG_Error(SWIG_AttributeError,"Variable ART_HARDDISK is read-only.");
18606 return 1;
18607 }
18608
18609
18610 SWIGINTERN PyObject *ART_HARDDISK_get(void) {
18611 PyObject *pyobj = 0;
18612
18613 {
18614 #if wxUSE_UNICODE
18615 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18616 #else
18617 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
18618 #endif
18619 }
18620 return pyobj;
18621 }
18622
18623
18624 SWIGINTERN int ART_FLOPPY_set(PyObject *) {
18625 SWIG_Error(SWIG_AttributeError,"Variable ART_FLOPPY is read-only.");
18626 return 1;
18627 }
18628
18629
18630 SWIGINTERN PyObject *ART_FLOPPY_get(void) {
18631 PyObject *pyobj = 0;
18632
18633 {
18634 #if wxUSE_UNICODE
18635 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18636 #else
18637 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
18638 #endif
18639 }
18640 return pyobj;
18641 }
18642
18643
18644 SWIGINTERN int ART_CDROM_set(PyObject *) {
18645 SWIG_Error(SWIG_AttributeError,"Variable ART_CDROM is read-only.");
18646 return 1;
18647 }
18648
18649
18650 SWIGINTERN PyObject *ART_CDROM_get(void) {
18651 PyObject *pyobj = 0;
18652
18653 {
18654 #if wxUSE_UNICODE
18655 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18656 #else
18657 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
18658 #endif
18659 }
18660 return pyobj;
18661 }
18662
18663
18664 SWIGINTERN int ART_REMOVABLE_set(PyObject *) {
18665 SWIG_Error(SWIG_AttributeError,"Variable ART_REMOVABLE is read-only.");
18666 return 1;
18667 }
18668
18669
18670 SWIGINTERN PyObject *ART_REMOVABLE_get(void) {
18671 PyObject *pyobj = 0;
18672
18673 {
18674 #if wxUSE_UNICODE
18675 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18676 #else
18677 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
18678 #endif
18679 }
18680 return pyobj;
18681 }
18682
18683
18684 SWIGINTERN int ART_FOLDER_set(PyObject *) {
18685 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER is read-only.");
18686 return 1;
18687 }
18688
18689
18690 SWIGINTERN PyObject *ART_FOLDER_get(void) {
18691 PyObject *pyobj = 0;
18692
18693 {
18694 #if wxUSE_UNICODE
18695 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18696 #else
18697 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
18698 #endif
18699 }
18700 return pyobj;
18701 }
18702
18703
18704 SWIGINTERN int ART_FOLDER_OPEN_set(PyObject *) {
18705 SWIG_Error(SWIG_AttributeError,"Variable ART_FOLDER_OPEN is read-only.");
18706 return 1;
18707 }
18708
18709
18710 SWIGINTERN PyObject *ART_FOLDER_OPEN_get(void) {
18711 PyObject *pyobj = 0;
18712
18713 {
18714 #if wxUSE_UNICODE
18715 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18716 #else
18717 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
18718 #endif
18719 }
18720 return pyobj;
18721 }
18722
18723
18724 SWIGINTERN int ART_GO_DIR_UP_set(PyObject *) {
18725 SWIG_Error(SWIG_AttributeError,"Variable ART_GO_DIR_UP is read-only.");
18726 return 1;
18727 }
18728
18729
18730 SWIGINTERN PyObject *ART_GO_DIR_UP_get(void) {
18731 PyObject *pyobj = 0;
18732
18733 {
18734 #if wxUSE_UNICODE
18735 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18736 #else
18737 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
18738 #endif
18739 }
18740 return pyobj;
18741 }
18742
18743
18744 SWIGINTERN int ART_EXECUTABLE_FILE_set(PyObject *) {
18745 SWIG_Error(SWIG_AttributeError,"Variable ART_EXECUTABLE_FILE is read-only.");
18746 return 1;
18747 }
18748
18749
18750 SWIGINTERN PyObject *ART_EXECUTABLE_FILE_get(void) {
18751 PyObject *pyobj = 0;
18752
18753 {
18754 #if wxUSE_UNICODE
18755 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18756 #else
18757 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
18758 #endif
18759 }
18760 return pyobj;
18761 }
18762
18763
18764 SWIGINTERN int ART_NORMAL_FILE_set(PyObject *) {
18765 SWIG_Error(SWIG_AttributeError,"Variable ART_NORMAL_FILE is read-only.");
18766 return 1;
18767 }
18768
18769
18770 SWIGINTERN PyObject *ART_NORMAL_FILE_get(void) {
18771 PyObject *pyobj = 0;
18772
18773 {
18774 #if wxUSE_UNICODE
18775 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18776 #else
18777 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
18778 #endif
18779 }
18780 return pyobj;
18781 }
18782
18783
18784 SWIGINTERN int ART_TICK_MARK_set(PyObject *) {
18785 SWIG_Error(SWIG_AttributeError,"Variable ART_TICK_MARK is read-only.");
18786 return 1;
18787 }
18788
18789
18790 SWIGINTERN PyObject *ART_TICK_MARK_get(void) {
18791 PyObject *pyobj = 0;
18792
18793 {
18794 #if wxUSE_UNICODE
18795 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18796 #else
18797 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
18798 #endif
18799 }
18800 return pyobj;
18801 }
18802
18803
18804 SWIGINTERN int ART_CROSS_MARK_set(PyObject *) {
18805 SWIG_Error(SWIG_AttributeError,"Variable ART_CROSS_MARK is read-only.");
18806 return 1;
18807 }
18808
18809
18810 SWIGINTERN PyObject *ART_CROSS_MARK_get(void) {
18811 PyObject *pyobj = 0;
18812
18813 {
18814 #if wxUSE_UNICODE
18815 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18816 #else
18817 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
18818 #endif
18819 }
18820 return pyobj;
18821 }
18822
18823
18824 SWIGINTERN int ART_ERROR_set(PyObject *) {
18825 SWIG_Error(SWIG_AttributeError,"Variable ART_ERROR is read-only.");
18826 return 1;
18827 }
18828
18829
18830 SWIGINTERN PyObject *ART_ERROR_get(void) {
18831 PyObject *pyobj = 0;
18832
18833 {
18834 #if wxUSE_UNICODE
18835 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18836 #else
18837 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
18838 #endif
18839 }
18840 return pyobj;
18841 }
18842
18843
18844 SWIGINTERN int ART_QUESTION_set(PyObject *) {
18845 SWIG_Error(SWIG_AttributeError,"Variable ART_QUESTION is read-only.");
18846 return 1;
18847 }
18848
18849
18850 SWIGINTERN PyObject *ART_QUESTION_get(void) {
18851 PyObject *pyobj = 0;
18852
18853 {
18854 #if wxUSE_UNICODE
18855 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18856 #else
18857 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
18858 #endif
18859 }
18860 return pyobj;
18861 }
18862
18863
18864 SWIGINTERN int ART_WARNING_set(PyObject *) {
18865 SWIG_Error(SWIG_AttributeError,"Variable ART_WARNING is read-only.");
18866 return 1;
18867 }
18868
18869
18870 SWIGINTERN PyObject *ART_WARNING_get(void) {
18871 PyObject *pyobj = 0;
18872
18873 {
18874 #if wxUSE_UNICODE
18875 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18876 #else
18877 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
18878 #endif
18879 }
18880 return pyobj;
18881 }
18882
18883
18884 SWIGINTERN int ART_INFORMATION_set(PyObject *) {
18885 SWIG_Error(SWIG_AttributeError,"Variable ART_INFORMATION is read-only.");
18886 return 1;
18887 }
18888
18889
18890 SWIGINTERN PyObject *ART_INFORMATION_get(void) {
18891 PyObject *pyobj = 0;
18892
18893 {
18894 #if wxUSE_UNICODE
18895 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18896 #else
18897 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
18898 #endif
18899 }
18900 return pyobj;
18901 }
18902
18903
18904 SWIGINTERN int ART_MISSING_IMAGE_set(PyObject *) {
18905 SWIG_Error(SWIG_AttributeError,"Variable ART_MISSING_IMAGE is read-only.");
18906 return 1;
18907 }
18908
18909
18910 SWIGINTERN PyObject *ART_MISSING_IMAGE_get(void) {
18911 PyObject *pyobj = 0;
18912
18913 {
18914 #if wxUSE_UNICODE
18915 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18916 #else
18917 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
18918 #endif
18919 }
18920 return pyobj;
18921 }
18922
18923
18924 SWIGINTERN int ART_COPY_set(PyObject *) {
18925 SWIG_Error(SWIG_AttributeError,"Variable ART_COPY is read-only.");
18926 return 1;
18927 }
18928
18929
18930 SWIGINTERN PyObject *ART_COPY_get(void) {
18931 PyObject *pyobj = 0;
18932
18933 {
18934 #if wxUSE_UNICODE
18935 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18936 #else
18937 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
18938 #endif
18939 }
18940 return pyobj;
18941 }
18942
18943
18944 SWIGINTERN int ART_CUT_set(PyObject *) {
18945 SWIG_Error(SWIG_AttributeError,"Variable ART_CUT is read-only.");
18946 return 1;
18947 }
18948
18949
18950 SWIGINTERN PyObject *ART_CUT_get(void) {
18951 PyObject *pyobj = 0;
18952
18953 {
18954 #if wxUSE_UNICODE
18955 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18956 #else
18957 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
18958 #endif
18959 }
18960 return pyobj;
18961 }
18962
18963
18964 SWIGINTERN int ART_PASTE_set(PyObject *) {
18965 SWIG_Error(SWIG_AttributeError,"Variable ART_PASTE is read-only.");
18966 return 1;
18967 }
18968
18969
18970 SWIGINTERN PyObject *ART_PASTE_get(void) {
18971 PyObject *pyobj = 0;
18972
18973 {
18974 #if wxUSE_UNICODE
18975 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18976 #else
18977 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
18978 #endif
18979 }
18980 return pyobj;
18981 }
18982
18983
18984 SWIGINTERN int ART_DELETE_set(PyObject *) {
18985 SWIG_Error(SWIG_AttributeError,"Variable ART_DELETE is read-only.");
18986 return 1;
18987 }
18988
18989
18990 SWIGINTERN PyObject *ART_DELETE_get(void) {
18991 PyObject *pyobj = 0;
18992
18993 {
18994 #if wxUSE_UNICODE
18995 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18996 #else
18997 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
18998 #endif
18999 }
19000 return pyobj;
19001 }
19002
19003
19004 SWIGINTERN int ART_NEW_set(PyObject *) {
19005 SWIG_Error(SWIG_AttributeError,"Variable ART_NEW is read-only.");
19006 return 1;
19007 }
19008
19009
19010 SWIGINTERN PyObject *ART_NEW_get(void) {
19011 PyObject *pyobj = 0;
19012
19013 {
19014 #if wxUSE_UNICODE
19015 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19016 #else
19017 pyobj = PyString_FromStringAndSize((&wxPyART_NEW)->c_str(), (&wxPyART_NEW)->Len());
19018 #endif
19019 }
19020 return pyobj;
19021 }
19022
19023
19024 SWIGINTERN int ART_UNDO_set(PyObject *) {
19025 SWIG_Error(SWIG_AttributeError,"Variable ART_UNDO is read-only.");
19026 return 1;
19027 }
19028
19029
19030 SWIGINTERN PyObject *ART_UNDO_get(void) {
19031 PyObject *pyobj = 0;
19032
19033 {
19034 #if wxUSE_UNICODE
19035 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19036 #else
19037 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
19038 #endif
19039 }
19040 return pyobj;
19041 }
19042
19043
19044 SWIGINTERN int ART_REDO_set(PyObject *) {
19045 SWIG_Error(SWIG_AttributeError,"Variable ART_REDO is read-only.");
19046 return 1;
19047 }
19048
19049
19050 SWIGINTERN PyObject *ART_REDO_get(void) {
19051 PyObject *pyobj = 0;
19052
19053 {
19054 #if wxUSE_UNICODE
19055 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19056 #else
19057 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
19058 #endif
19059 }
19060 return pyobj;
19061 }
19062
19063
19064 SWIGINTERN int ART_QUIT_set(PyObject *) {
19065 SWIG_Error(SWIG_AttributeError,"Variable ART_QUIT is read-only.");
19066 return 1;
19067 }
19068
19069
19070 SWIGINTERN PyObject *ART_QUIT_get(void) {
19071 PyObject *pyobj = 0;
19072
19073 {
19074 #if wxUSE_UNICODE
19075 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19076 #else
19077 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
19078 #endif
19079 }
19080 return pyobj;
19081 }
19082
19083
19084 SWIGINTERN int ART_FIND_set(PyObject *) {
19085 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND is read-only.");
19086 return 1;
19087 }
19088
19089
19090 SWIGINTERN PyObject *ART_FIND_get(void) {
19091 PyObject *pyobj = 0;
19092
19093 {
19094 #if wxUSE_UNICODE
19095 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19096 #else
19097 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
19098 #endif
19099 }
19100 return pyobj;
19101 }
19102
19103
19104 SWIGINTERN int ART_FIND_AND_REPLACE_set(PyObject *) {
19105 SWIG_Error(SWIG_AttributeError,"Variable ART_FIND_AND_REPLACE is read-only.");
19106 return 1;
19107 }
19108
19109
19110 SWIGINTERN PyObject *ART_FIND_AND_REPLACE_get(void) {
19111 PyObject *pyobj = 0;
19112
19113 {
19114 #if wxUSE_UNICODE
19115 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19116 #else
19117 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
19118 #endif
19119 }
19120 return pyobj;
19121 }
19122
19123
19124 SWIGINTERN PyObject *_wrap_new_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19125 PyObject *resultobj = 0;
19126 wxPyArtProvider *result = 0 ;
19127
19128 if (!SWIG_Python_UnpackTuple(args,"new_ArtProvider",0,0,0)) SWIG_fail;
19129 {
19130 if (!wxPyCheckForApp()) SWIG_fail;
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 result = (wxPyArtProvider *)new wxPyArtProvider();
19133 wxPyEndAllowThreads(__tstate);
19134 if (PyErr_Occurred()) SWIG_fail;
19135 }
19136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_NEW | 0 );
19137 return resultobj;
19138 fail:
19139 return NULL;
19140 }
19141
19142
19143 SWIGINTERN PyObject *_wrap_delete_ArtProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19144 PyObject *resultobj = 0;
19145 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19146 void *argp1 = 0 ;
19147 int res1 = 0 ;
19148 PyObject *swig_obj[1] ;
19149
19150 if (!args) SWIG_fail;
19151 swig_obj[0] = args;
19152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19153 if (!SWIG_IsOK(res1)) {
19154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArtProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19155 }
19156 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19157 {
19158 PyThreadState* __tstate = wxPyBeginAllowThreads();
19159 delete arg1;
19160
19161 wxPyEndAllowThreads(__tstate);
19162 if (PyErr_Occurred()) SWIG_fail;
19163 }
19164 resultobj = SWIG_Py_Void();
19165 return resultobj;
19166 fail:
19167 return NULL;
19168 }
19169
19170
19171 SWIGINTERN PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19172 PyObject *resultobj = 0;
19173 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19174 PyObject *arg2 = (PyObject *) 0 ;
19175 PyObject *arg3 = (PyObject *) 0 ;
19176 void *argp1 = 0 ;
19177 int res1 = 0 ;
19178 PyObject * obj0 = 0 ;
19179 PyObject * obj1 = 0 ;
19180 PyObject * obj2 = 0 ;
19181 char * kwnames[] = {
19182 (char *) "self",(char *) "self",(char *) "_class", NULL
19183 };
19184
19185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19187 if (!SWIG_IsOK(res1)) {
19188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19189 }
19190 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19191 arg2 = obj1;
19192 arg3 = obj2;
19193 {
19194 PyThreadState* __tstate = wxPyBeginAllowThreads();
19195 (arg1)->_setCallbackInfo(arg2,arg3);
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 resultobj = SWIG_Py_Void();
19200 return resultobj;
19201 fail:
19202 return NULL;
19203 }
19204
19205
19206 SWIGINTERN PyObject *_wrap_ArtProvider_PushProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19207 PyObject *resultobj = 0;
19208 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19209 int res1 = 0 ;
19210 PyObject * obj0 = 0 ;
19211 char * kwnames[] = {
19212 (char *) "provider", NULL
19213 };
19214
19215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) SWIG_fail;
19216 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_DISOWN | 0 );
19217 if (!SWIG_IsOK(res1)) {
19218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_PushProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19219 }
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 wxPyArtProvider::PushProvider(arg1);
19223 wxPyEndAllowThreads(__tstate);
19224 if (PyErr_Occurred()) SWIG_fail;
19225 }
19226 resultobj = SWIG_Py_Void();
19227 return resultobj;
19228 fail:
19229 return NULL;
19230 }
19231
19232
19233 SWIGINTERN PyObject *_wrap_ArtProvider_PopProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19234 PyObject *resultobj = 0;
19235 bool result;
19236
19237 if (!SWIG_Python_UnpackTuple(args,"ArtProvider_PopProvider",0,0,0)) SWIG_fail;
19238 {
19239 PyThreadState* __tstate = wxPyBeginAllowThreads();
19240 result = (bool)wxPyArtProvider::PopProvider();
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 {
19245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19246 }
19247 return resultobj;
19248 fail:
19249 return NULL;
19250 }
19251
19252
19253 SWIGINTERN PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19254 PyObject *resultobj = 0;
19255 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19256 bool result;
19257 void *argp1 = 0 ;
19258 int res1 = 0 ;
19259 PyObject * obj0 = 0 ;
19260 char * kwnames[] = {
19261 (char *) "provider", NULL
19262 };
19263
19264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) SWIG_fail;
19265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19266 if (!SWIG_IsOK(res1)) {
19267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_RemoveProvider" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19268 }
19269 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 {
19277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19278 }
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 SWIGINTERN PyObject *_wrap_ArtProvider_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj = 0;
19287 wxString *arg1 = 0 ;
19288 wxString const &arg2_defvalue = wxPyART_OTHER ;
19289 wxString *arg2 = (wxString *) &arg2_defvalue ;
19290 wxSize const &arg3_defvalue = wxDefaultSize ;
19291 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19292 wxBitmap result;
19293 bool temp1 = false ;
19294 bool temp2 = false ;
19295 wxSize temp3 ;
19296 PyObject * obj0 = 0 ;
19297 PyObject * obj1 = 0 ;
19298 PyObject * obj2 = 0 ;
19299 char * kwnames[] = {
19300 (char *) "id",(char *) "client",(char *) "size", NULL
19301 };
19302
19303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19304 {
19305 arg1 = wxString_in_helper(obj0);
19306 if (arg1 == NULL) SWIG_fail;
19307 temp1 = true;
19308 }
19309 if (obj1) {
19310 {
19311 arg2 = wxString_in_helper(obj1);
19312 if (arg2 == NULL) SWIG_fail;
19313 temp2 = true;
19314 }
19315 }
19316 if (obj2) {
19317 {
19318 arg3 = &temp3;
19319 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19320 }
19321 }
19322 {
19323 if (!wxPyCheckForApp()) SWIG_fail;
19324 PyThreadState* __tstate = wxPyBeginAllowThreads();
19325 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19326 wxPyEndAllowThreads(__tstate);
19327 if (PyErr_Occurred()) SWIG_fail;
19328 }
19329 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19330 {
19331 if (temp1)
19332 delete arg1;
19333 }
19334 {
19335 if (temp2)
19336 delete arg2;
19337 }
19338 return resultobj;
19339 fail:
19340 {
19341 if (temp1)
19342 delete arg1;
19343 }
19344 {
19345 if (temp2)
19346 delete arg2;
19347 }
19348 return NULL;
19349 }
19350
19351
19352 SWIGINTERN PyObject *_wrap_ArtProvider_GetIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19353 PyObject *resultobj = 0;
19354 wxString *arg1 = 0 ;
19355 wxString const &arg2_defvalue = wxPyART_OTHER ;
19356 wxString *arg2 = (wxString *) &arg2_defvalue ;
19357 wxSize const &arg3_defvalue = wxDefaultSize ;
19358 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
19359 wxIcon result;
19360 bool temp1 = false ;
19361 bool temp2 = false ;
19362 wxSize temp3 ;
19363 PyObject * obj0 = 0 ;
19364 PyObject * obj1 = 0 ;
19365 PyObject * obj2 = 0 ;
19366 char * kwnames[] = {
19367 (char *) "id",(char *) "client",(char *) "size", NULL
19368 };
19369
19370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19371 {
19372 arg1 = wxString_in_helper(obj0);
19373 if (arg1 == NULL) SWIG_fail;
19374 temp1 = true;
19375 }
19376 if (obj1) {
19377 {
19378 arg2 = wxString_in_helper(obj1);
19379 if (arg2 == NULL) SWIG_fail;
19380 temp2 = true;
19381 }
19382 }
19383 if (obj2) {
19384 {
19385 arg3 = &temp3;
19386 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
19387 }
19388 }
19389 {
19390 if (!wxPyCheckForApp()) SWIG_fail;
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_NewPointerObj((new wxIcon(static_cast< const wxIcon& >(result))), SWIGTYPE_p_wxIcon, SWIG_POINTER_OWN | 0 );
19397 {
19398 if (temp1)
19399 delete arg1;
19400 }
19401 {
19402 if (temp2)
19403 delete arg2;
19404 }
19405 return resultobj;
19406 fail:
19407 {
19408 if (temp1)
19409 delete arg1;
19410 }
19411 {
19412 if (temp2)
19413 delete arg2;
19414 }
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj = 0;
19421 wxString *arg1 = 0 ;
19422 bool arg2 = (bool) false ;
19423 wxSize result;
19424 bool temp1 = false ;
19425 bool val2 ;
19426 int ecode2 = 0 ;
19427 PyObject * obj0 = 0 ;
19428 PyObject * obj1 = 0 ;
19429 char * kwnames[] = {
19430 (char *) "client",(char *) "platform_dependent", NULL
19431 };
19432
19433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) SWIG_fail;
19434 {
19435 arg1 = wxString_in_helper(obj0);
19436 if (arg1 == NULL) SWIG_fail;
19437 temp1 = true;
19438 }
19439 if (obj1) {
19440 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19441 if (!SWIG_IsOK(ecode2)) {
19442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArtProvider_GetSizeHint" "', expected argument " "2"" of type '" "bool""'");
19443 }
19444 arg2 = static_cast< bool >(val2);
19445 }
19446 {
19447 PyThreadState* __tstate = wxPyBeginAllowThreads();
19448 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
19453 {
19454 if (temp1)
19455 delete arg1;
19456 }
19457 return resultobj;
19458 fail:
19459 {
19460 if (temp1)
19461 delete arg1;
19462 }
19463 return NULL;
19464 }
19465
19466
19467 SWIGINTERN PyObject *_wrap_ArtProvider_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19468 PyObject *resultobj = 0;
19469 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
19470 void *argp1 = 0 ;
19471 int res1 = 0 ;
19472 PyObject *swig_obj[1] ;
19473
19474 if (!args) SWIG_fail;
19475 swig_obj[0] = args;
19476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyArtProvider, 0 | 0 );
19477 if (!SWIG_IsOK(res1)) {
19478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArtProvider_Destroy" "', expected argument " "1"" of type '" "wxPyArtProvider *""'");
19479 }
19480 arg1 = reinterpret_cast< wxPyArtProvider * >(argp1);
19481 {
19482 PyThreadState* __tstate = wxPyBeginAllowThreads();
19483 wxPyArtProvider_Destroy(arg1);
19484 wxPyEndAllowThreads(__tstate);
19485 if (PyErr_Occurred()) SWIG_fail;
19486 }
19487 resultobj = SWIG_Py_Void();
19488 return resultobj;
19489 fail:
19490 return NULL;
19491 }
19492
19493
19494 SWIGINTERN PyObject *ArtProvider_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19495 PyObject *obj;
19496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19497 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyArtProvider, SWIG_NewClientData(obj));
19498 return SWIG_Py_Void();
19499 }
19500
19501 SWIGINTERN PyObject *ArtProvider_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19502 return SWIG_Python_InitShadowInstance(args);
19503 }
19504
19505 SWIGINTERN PyObject *_wrap_delete_ConfigBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19506 PyObject *resultobj = 0;
19507 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19508 void *argp1 = 0 ;
19509 int res1 = 0 ;
19510 PyObject *swig_obj[1] ;
19511
19512 if (!args) SWIG_fail;
19513 swig_obj[0] = args;
19514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19515 if (!SWIG_IsOK(res1)) {
19516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigBase" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19517 }
19518 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 delete arg1;
19522
19523 wxPyEndAllowThreads(__tstate);
19524 if (PyErr_Occurred()) SWIG_fail;
19525 }
19526 resultobj = SWIG_Py_Void();
19527 return resultobj;
19528 fail:
19529 return NULL;
19530 }
19531
19532
19533 SWIGINTERN PyObject *_wrap_ConfigBase_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19534 PyObject *resultobj = 0;
19535 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19536 wxConfigBase *result = 0 ;
19537 int res1 = 0 ;
19538 PyObject * obj0 = 0 ;
19539 char * kwnames[] = {
19540 (char *) "config", NULL
19541 };
19542
19543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) SWIG_fail;
19544 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxConfigBase, SWIG_POINTER_DISOWN | 0 );
19545 if (!SWIG_IsOK(res1)) {
19546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Set" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19547 }
19548 {
19549 PyThreadState* __tstate = wxPyBeginAllowThreads();
19550 result = (wxConfigBase *)wxConfigBase::Set(arg1);
19551 wxPyEndAllowThreads(__tstate);
19552 if (PyErr_Occurred()) SWIG_fail;
19553 }
19554 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19555 return resultobj;
19556 fail:
19557 return NULL;
19558 }
19559
19560
19561 SWIGINTERN PyObject *_wrap_ConfigBase_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19562 PyObject *resultobj = 0;
19563 bool arg1 = (bool) true ;
19564 wxConfigBase *result = 0 ;
19565 bool val1 ;
19566 int ecode1 = 0 ;
19567 PyObject * obj0 = 0 ;
19568 char * kwnames[] = {
19569 (char *) "createOnDemand", NULL
19570 };
19571
19572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) SWIG_fail;
19573 if (obj0) {
19574 ecode1 = SWIG_AsVal_bool(obj0, &val1);
19575 if (!SWIG_IsOK(ecode1)) {
19576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ConfigBase_Get" "', expected argument " "1"" of type '" "bool""'");
19577 }
19578 arg1 = static_cast< bool >(val1);
19579 }
19580 {
19581 PyThreadState* __tstate = wxPyBeginAllowThreads();
19582 result = (wxConfigBase *)wxConfigBase::Get(arg1);
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19587 return resultobj;
19588 fail:
19589 return NULL;
19590 }
19591
19592
19593 SWIGINTERN PyObject *_wrap_ConfigBase_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19594 PyObject *resultobj = 0;
19595 wxConfigBase *result = 0 ;
19596
19597 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_Create",0,0,0)) SWIG_fail;
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 result = (wxConfigBase *)wxConfigBase::Create();
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigBase, 0 | 0 );
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 SWIGINTERN PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19612 PyObject *resultobj = 0;
19613
19614 if (!SWIG_Python_UnpackTuple(args,"ConfigBase_DontCreateOnDemand",0,0,0)) SWIG_fail;
19615 {
19616 PyThreadState* __tstate = wxPyBeginAllowThreads();
19617 wxConfigBase::DontCreateOnDemand();
19618 wxPyEndAllowThreads(__tstate);
19619 if (PyErr_Occurred()) SWIG_fail;
19620 }
19621 resultobj = SWIG_Py_Void();
19622 return resultobj;
19623 fail:
19624 return NULL;
19625 }
19626
19627
19628 SWIGINTERN PyObject *_wrap_ConfigBase_SetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19629 PyObject *resultobj = 0;
19630 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19631 wxString *arg2 = 0 ;
19632 void *argp1 = 0 ;
19633 int res1 = 0 ;
19634 bool temp2 = false ;
19635 PyObject * obj0 = 0 ;
19636 PyObject * obj1 = 0 ;
19637 char * kwnames[] = {
19638 (char *) "self",(char *) "path", NULL
19639 };
19640
19641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) SWIG_fail;
19642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19643 if (!SWIG_IsOK(res1)) {
19644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetPath" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19645 }
19646 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19647 {
19648 arg2 = wxString_in_helper(obj1);
19649 if (arg2 == NULL) SWIG_fail;
19650 temp2 = true;
19651 }
19652 {
19653 PyThreadState* __tstate = wxPyBeginAllowThreads();
19654 (arg1)->SetPath((wxString const &)*arg2);
19655 wxPyEndAllowThreads(__tstate);
19656 if (PyErr_Occurred()) SWIG_fail;
19657 }
19658 resultobj = SWIG_Py_Void();
19659 {
19660 if (temp2)
19661 delete arg2;
19662 }
19663 return resultobj;
19664 fail:
19665 {
19666 if (temp2)
19667 delete arg2;
19668 }
19669 return NULL;
19670 }
19671
19672
19673 SWIGINTERN PyObject *_wrap_ConfigBase_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19674 PyObject *resultobj = 0;
19675 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19676 wxString *result = 0 ;
19677 void *argp1 = 0 ;
19678 int res1 = 0 ;
19679 PyObject *swig_obj[1] ;
19680
19681 if (!args) SWIG_fail;
19682 swig_obj[0] = args;
19683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19684 if (!SWIG_IsOK(res1)) {
19685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetPath" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19686 }
19687 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19688 {
19689 PyThreadState* __tstate = wxPyBeginAllowThreads();
19690 {
19691 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
19692 result = (wxString *) &_result_ref;
19693 }
19694 wxPyEndAllowThreads(__tstate);
19695 if (PyErr_Occurred()) SWIG_fail;
19696 }
19697 {
19698 #if wxUSE_UNICODE
19699 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
19700 #else
19701 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
19702 #endif
19703 }
19704 return resultobj;
19705 fail:
19706 return NULL;
19707 }
19708
19709
19710 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19711 PyObject *resultobj = 0;
19712 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19713 PyObject *result = 0 ;
19714 void *argp1 = 0 ;
19715 int res1 = 0 ;
19716 PyObject *swig_obj[1] ;
19717
19718 if (!args) SWIG_fail;
19719 swig_obj[0] = args;
19720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19721 if (!SWIG_IsOK(res1)) {
19722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19723 }
19724 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19725 {
19726 PyThreadState* __tstate = wxPyBeginAllowThreads();
19727 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
19728 wxPyEndAllowThreads(__tstate);
19729 if (PyErr_Occurred()) SWIG_fail;
19730 }
19731 resultobj = result;
19732 return resultobj;
19733 fail:
19734 return NULL;
19735 }
19736
19737
19738 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj = 0;
19740 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19741 long arg2 ;
19742 PyObject *result = 0 ;
19743 void *argp1 = 0 ;
19744 int res1 = 0 ;
19745 long val2 ;
19746 int ecode2 = 0 ;
19747 PyObject * obj0 = 0 ;
19748 PyObject * obj1 = 0 ;
19749 char * kwnames[] = {
19750 (char *) "self",(char *) "index", NULL
19751 };
19752
19753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19755 if (!SWIG_IsOK(res1)) {
19756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19757 }
19758 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19759 ecode2 = SWIG_AsVal_long(obj1, &val2);
19760 if (!SWIG_IsOK(ecode2)) {
19761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextGroup" "', expected argument " "2"" of type '" "long""'");
19762 }
19763 arg2 = static_cast< long >(val2);
19764 {
19765 PyThreadState* __tstate = wxPyBeginAllowThreads();
19766 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
19767 wxPyEndAllowThreads(__tstate);
19768 if (PyErr_Occurred()) SWIG_fail;
19769 }
19770 resultobj = result;
19771 return resultobj;
19772 fail:
19773 return NULL;
19774 }
19775
19776
19777 SWIGINTERN PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19778 PyObject *resultobj = 0;
19779 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19780 PyObject *result = 0 ;
19781 void *argp1 = 0 ;
19782 int res1 = 0 ;
19783 PyObject *swig_obj[1] ;
19784
19785 if (!args) SWIG_fail;
19786 swig_obj[0] = args;
19787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19788 if (!SWIG_IsOK(res1)) {
19789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetFirstEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19790 }
19791 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19792 {
19793 PyThreadState* __tstate = wxPyBeginAllowThreads();
19794 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
19795 wxPyEndAllowThreads(__tstate);
19796 if (PyErr_Occurred()) SWIG_fail;
19797 }
19798 resultobj = result;
19799 return resultobj;
19800 fail:
19801 return NULL;
19802 }
19803
19804
19805 SWIGINTERN PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj = 0;
19807 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19808 long arg2 ;
19809 PyObject *result = 0 ;
19810 void *argp1 = 0 ;
19811 int res1 = 0 ;
19812 long val2 ;
19813 int ecode2 = 0 ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char * kwnames[] = {
19817 (char *) "self",(char *) "index", NULL
19818 };
19819
19820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19822 if (!SWIG_IsOK(res1)) {
19823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
19824 }
19825 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19826 ecode2 = SWIG_AsVal_long(obj1, &val2);
19827 if (!SWIG_IsOK(ecode2)) {
19828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNextEntry" "', expected argument " "2"" of type '" "long""'");
19829 }
19830 arg2 = static_cast< long >(val2);
19831 {
19832 PyThreadState* __tstate = wxPyBeginAllowThreads();
19833 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
19834 wxPyEndAllowThreads(__tstate);
19835 if (PyErr_Occurred()) SWIG_fail;
19836 }
19837 resultobj = result;
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19845 PyObject *resultobj = 0;
19846 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19847 bool arg2 = (bool) false ;
19848 size_t result;
19849 void *argp1 = 0 ;
19850 int res1 = 0 ;
19851 bool val2 ;
19852 int ecode2 = 0 ;
19853 PyObject * obj0 = 0 ;
19854 PyObject * obj1 = 0 ;
19855 char * kwnames[] = {
19856 (char *) "self",(char *) "recursive", NULL
19857 };
19858
19859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) SWIG_fail;
19860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19861 if (!SWIG_IsOK(res1)) {
19862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19863 }
19864 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19865 if (obj1) {
19866 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19867 if (!SWIG_IsOK(ecode2)) {
19868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfEntries" "', expected argument " "2"" of type '" "bool""'");
19869 }
19870 arg2 = static_cast< bool >(val2);
19871 }
19872 {
19873 PyThreadState* __tstate = wxPyBeginAllowThreads();
19874 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 SWIGINTERN PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj = 0;
19887 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19888 bool arg2 = (bool) false ;
19889 size_t result;
19890 void *argp1 = 0 ;
19891 int res1 = 0 ;
19892 bool val2 ;
19893 int ecode2 = 0 ;
19894 PyObject * obj0 = 0 ;
19895 PyObject * obj1 = 0 ;
19896 char * kwnames[] = {
19897 (char *) "self",(char *) "recursive", NULL
19898 };
19899
19900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) SWIG_fail;
19901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19902 if (!SWIG_IsOK(res1)) {
19903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19904 }
19905 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19906 if (obj1) {
19907 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19908 if (!SWIG_IsOK(ecode2)) {
19909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_GetNumberOfGroups" "', expected argument " "2"" of type '" "bool""'");
19910 }
19911 arg2 = static_cast< bool >(val2);
19912 }
19913 {
19914 PyThreadState* __tstate = wxPyBeginAllowThreads();
19915 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 SWIGINTERN PyObject *_wrap_ConfigBase_HasGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19927 PyObject *resultobj = 0;
19928 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19929 wxString *arg2 = 0 ;
19930 bool result;
19931 void *argp1 = 0 ;
19932 int res1 = 0 ;
19933 bool temp2 = false ;
19934 PyObject * obj0 = 0 ;
19935 PyObject * obj1 = 0 ;
19936 char * kwnames[] = {
19937 (char *) "self",(char *) "name", NULL
19938 };
19939
19940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) SWIG_fail;
19941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19942 if (!SWIG_IsOK(res1)) {
19943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasGroup" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19944 }
19945 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19946 {
19947 arg2 = wxString_in_helper(obj1);
19948 if (arg2 == NULL) SWIG_fail;
19949 temp2 = true;
19950 }
19951 {
19952 PyThreadState* __tstate = wxPyBeginAllowThreads();
19953 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
19954 wxPyEndAllowThreads(__tstate);
19955 if (PyErr_Occurred()) SWIG_fail;
19956 }
19957 {
19958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19959 }
19960 {
19961 if (temp2)
19962 delete arg2;
19963 }
19964 return resultobj;
19965 fail:
19966 {
19967 if (temp2)
19968 delete arg2;
19969 }
19970 return NULL;
19971 }
19972
19973
19974 SWIGINTERN PyObject *_wrap_ConfigBase_HasEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19975 PyObject *resultobj = 0;
19976 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
19977 wxString *arg2 = 0 ;
19978 bool result;
19979 void *argp1 = 0 ;
19980 int res1 = 0 ;
19981 bool temp2 = false ;
19982 PyObject * obj0 = 0 ;
19983 PyObject * obj1 = 0 ;
19984 char * kwnames[] = {
19985 (char *) "self",(char *) "name", NULL
19986 };
19987
19988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) SWIG_fail;
19989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
19990 if (!SWIG_IsOK(res1)) {
19991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_HasEntry" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
19992 }
19993 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
19994 {
19995 arg2 = wxString_in_helper(obj1);
19996 if (arg2 == NULL) SWIG_fail;
19997 temp2 = true;
19998 }
19999 {
20000 PyThreadState* __tstate = wxPyBeginAllowThreads();
20001 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
20002 wxPyEndAllowThreads(__tstate);
20003 if (PyErr_Occurred()) SWIG_fail;
20004 }
20005 {
20006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20007 }
20008 {
20009 if (temp2)
20010 delete arg2;
20011 }
20012 return resultobj;
20013 fail:
20014 {
20015 if (temp2)
20016 delete arg2;
20017 }
20018 return NULL;
20019 }
20020
20021
20022 SWIGINTERN PyObject *_wrap_ConfigBase_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20023 PyObject *resultobj = 0;
20024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20025 wxString *arg2 = 0 ;
20026 bool result;
20027 void *argp1 = 0 ;
20028 int res1 = 0 ;
20029 bool temp2 = false ;
20030 PyObject * obj0 = 0 ;
20031 PyObject * obj1 = 0 ;
20032 char * kwnames[] = {
20033 (char *) "self",(char *) "name", NULL
20034 };
20035
20036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) SWIG_fail;
20037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20038 if (!SWIG_IsOK(res1)) {
20039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Exists" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20040 }
20041 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20042 {
20043 arg2 = wxString_in_helper(obj1);
20044 if (arg2 == NULL) SWIG_fail;
20045 temp2 = true;
20046 }
20047 {
20048 PyThreadState* __tstate = wxPyBeginAllowThreads();
20049 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
20050 wxPyEndAllowThreads(__tstate);
20051 if (PyErr_Occurred()) SWIG_fail;
20052 }
20053 {
20054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20055 }
20056 {
20057 if (temp2)
20058 delete arg2;
20059 }
20060 return resultobj;
20061 fail:
20062 {
20063 if (temp2)
20064 delete arg2;
20065 }
20066 return NULL;
20067 }
20068
20069
20070 SWIGINTERN PyObject *_wrap_ConfigBase_GetEntryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20071 PyObject *resultobj = 0;
20072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20073 wxString *arg2 = 0 ;
20074 wxConfigBase::EntryType result;
20075 void *argp1 = 0 ;
20076 int res1 = 0 ;
20077 bool temp2 = false ;
20078 PyObject * obj0 = 0 ;
20079 PyObject * obj1 = 0 ;
20080 char * kwnames[] = {
20081 (char *) "self",(char *) "name", NULL
20082 };
20083
20084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) SWIG_fail;
20085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20086 if (!SWIG_IsOK(res1)) {
20087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetEntryType" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20088 }
20089 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20090 {
20091 arg2 = wxString_in_helper(obj1);
20092 if (arg2 == NULL) SWIG_fail;
20093 temp2 = true;
20094 }
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
20098 wxPyEndAllowThreads(__tstate);
20099 if (PyErr_Occurred()) SWIG_fail;
20100 }
20101 resultobj = SWIG_From_int(static_cast< int >(result));
20102 {
20103 if (temp2)
20104 delete arg2;
20105 }
20106 return resultobj;
20107 fail:
20108 {
20109 if (temp2)
20110 delete arg2;
20111 }
20112 return NULL;
20113 }
20114
20115
20116 SWIGINTERN PyObject *_wrap_ConfigBase_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20117 PyObject *resultobj = 0;
20118 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20119 wxString *arg2 = 0 ;
20120 wxString const &arg3_defvalue = wxPyEmptyString ;
20121 wxString *arg3 = (wxString *) &arg3_defvalue ;
20122 wxString result;
20123 void *argp1 = 0 ;
20124 int res1 = 0 ;
20125 bool temp2 = false ;
20126 bool temp3 = false ;
20127 PyObject * obj0 = 0 ;
20128 PyObject * obj1 = 0 ;
20129 PyObject * obj2 = 0 ;
20130 char * kwnames[] = {
20131 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20132 };
20133
20134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20136 if (!SWIG_IsOK(res1)) {
20137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Read" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20138 }
20139 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20140 {
20141 arg2 = wxString_in_helper(obj1);
20142 if (arg2 == NULL) SWIG_fail;
20143 temp2 = true;
20144 }
20145 if (obj2) {
20146 {
20147 arg3 = wxString_in_helper(obj2);
20148 if (arg3 == NULL) SWIG_fail;
20149 temp3 = true;
20150 }
20151 }
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
20155 wxPyEndAllowThreads(__tstate);
20156 if (PyErr_Occurred()) SWIG_fail;
20157 }
20158 {
20159 #if wxUSE_UNICODE
20160 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20161 #else
20162 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20163 #endif
20164 }
20165 {
20166 if (temp2)
20167 delete arg2;
20168 }
20169 {
20170 if (temp3)
20171 delete arg3;
20172 }
20173 return resultobj;
20174 fail:
20175 {
20176 if (temp2)
20177 delete arg2;
20178 }
20179 {
20180 if (temp3)
20181 delete arg3;
20182 }
20183 return NULL;
20184 }
20185
20186
20187 SWIGINTERN PyObject *_wrap_ConfigBase_ReadInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20188 PyObject *resultobj = 0;
20189 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20190 wxString *arg2 = 0 ;
20191 long arg3 = (long) 0 ;
20192 long result;
20193 void *argp1 = 0 ;
20194 int res1 = 0 ;
20195 bool temp2 = false ;
20196 long val3 ;
20197 int ecode3 = 0 ;
20198 PyObject * obj0 = 0 ;
20199 PyObject * obj1 = 0 ;
20200 PyObject * obj2 = 0 ;
20201 char * kwnames[] = {
20202 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20203 };
20204
20205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20207 if (!SWIG_IsOK(res1)) {
20208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20209 }
20210 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20211 {
20212 arg2 = wxString_in_helper(obj1);
20213 if (arg2 == NULL) SWIG_fail;
20214 temp2 = true;
20215 }
20216 if (obj2) {
20217 ecode3 = SWIG_AsVal_long(obj2, &val3);
20218 if (!SWIG_IsOK(ecode3)) {
20219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadInt" "', expected argument " "3"" of type '" "long""'");
20220 }
20221 arg3 = static_cast< long >(val3);
20222 }
20223 {
20224 PyThreadState* __tstate = wxPyBeginAllowThreads();
20225 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 resultobj = SWIG_From_long(static_cast< long >(result));
20230 {
20231 if (temp2)
20232 delete arg2;
20233 }
20234 return resultobj;
20235 fail:
20236 {
20237 if (temp2)
20238 delete arg2;
20239 }
20240 return NULL;
20241 }
20242
20243
20244 SWIGINTERN PyObject *_wrap_ConfigBase_ReadFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20245 PyObject *resultobj = 0;
20246 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20247 wxString *arg2 = 0 ;
20248 double arg3 = (double) 0.0 ;
20249 double result;
20250 void *argp1 = 0 ;
20251 int res1 = 0 ;
20252 bool temp2 = false ;
20253 double val3 ;
20254 int ecode3 = 0 ;
20255 PyObject * obj0 = 0 ;
20256 PyObject * obj1 = 0 ;
20257 PyObject * obj2 = 0 ;
20258 char * kwnames[] = {
20259 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20260 };
20261
20262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20264 if (!SWIG_IsOK(res1)) {
20265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20266 }
20267 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20268 {
20269 arg2 = wxString_in_helper(obj1);
20270 if (arg2 == NULL) SWIG_fail;
20271 temp2 = true;
20272 }
20273 if (obj2) {
20274 ecode3 = SWIG_AsVal_double(obj2, &val3);
20275 if (!SWIG_IsOK(ecode3)) {
20276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadFloat" "', expected argument " "3"" of type '" "double""'");
20277 }
20278 arg3 = static_cast< double >(val3);
20279 }
20280 {
20281 PyThreadState* __tstate = wxPyBeginAllowThreads();
20282 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
20283 wxPyEndAllowThreads(__tstate);
20284 if (PyErr_Occurred()) SWIG_fail;
20285 }
20286 resultobj = SWIG_From_double(static_cast< double >(result));
20287 {
20288 if (temp2)
20289 delete arg2;
20290 }
20291 return resultobj;
20292 fail:
20293 {
20294 if (temp2)
20295 delete arg2;
20296 }
20297 return NULL;
20298 }
20299
20300
20301 SWIGINTERN PyObject *_wrap_ConfigBase_ReadBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20302 PyObject *resultobj = 0;
20303 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20304 wxString *arg2 = 0 ;
20305 bool arg3 = (bool) false ;
20306 bool result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 bool temp2 = false ;
20310 bool val3 ;
20311 int ecode3 = 0 ;
20312 PyObject * obj0 = 0 ;
20313 PyObject * obj1 = 0 ;
20314 PyObject * obj2 = 0 ;
20315 char * kwnames[] = {
20316 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
20317 };
20318
20319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20321 if (!SWIG_IsOK(res1)) {
20322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ReadBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20323 }
20324 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20325 {
20326 arg2 = wxString_in_helper(obj1);
20327 if (arg2 == NULL) SWIG_fail;
20328 temp2 = true;
20329 }
20330 if (obj2) {
20331 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20332 if (!SWIG_IsOK(ecode3)) {
20333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_ReadBool" "', expected argument " "3"" of type '" "bool""'");
20334 }
20335 arg3 = static_cast< bool >(val3);
20336 }
20337 {
20338 PyThreadState* __tstate = wxPyBeginAllowThreads();
20339 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 {
20344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20345 }
20346 {
20347 if (temp2)
20348 delete arg2;
20349 }
20350 return resultobj;
20351 fail:
20352 {
20353 if (temp2)
20354 delete arg2;
20355 }
20356 return NULL;
20357 }
20358
20359
20360 SWIGINTERN PyObject *_wrap_ConfigBase_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20361 PyObject *resultobj = 0;
20362 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20363 wxString *arg2 = 0 ;
20364 wxString *arg3 = 0 ;
20365 bool result;
20366 void *argp1 = 0 ;
20367 int res1 = 0 ;
20368 bool temp2 = false ;
20369 bool temp3 = false ;
20370 PyObject * obj0 = 0 ;
20371 PyObject * obj1 = 0 ;
20372 PyObject * obj2 = 0 ;
20373 char * kwnames[] = {
20374 (char *) "self",(char *) "key",(char *) "value", NULL
20375 };
20376
20377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20379 if (!SWIG_IsOK(res1)) {
20380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Write" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20381 }
20382 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20383 {
20384 arg2 = wxString_in_helper(obj1);
20385 if (arg2 == NULL) SWIG_fail;
20386 temp2 = true;
20387 }
20388 {
20389 arg3 = wxString_in_helper(obj2);
20390 if (arg3 == NULL) SWIG_fail;
20391 temp3 = true;
20392 }
20393 {
20394 PyThreadState* __tstate = wxPyBeginAllowThreads();
20395 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
20396 wxPyEndAllowThreads(__tstate);
20397 if (PyErr_Occurred()) SWIG_fail;
20398 }
20399 {
20400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20401 }
20402 {
20403 if (temp2)
20404 delete arg2;
20405 }
20406 {
20407 if (temp3)
20408 delete arg3;
20409 }
20410 return resultobj;
20411 fail:
20412 {
20413 if (temp2)
20414 delete arg2;
20415 }
20416 {
20417 if (temp3)
20418 delete arg3;
20419 }
20420 return NULL;
20421 }
20422
20423
20424 SWIGINTERN PyObject *_wrap_ConfigBase_WriteInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20425 PyObject *resultobj = 0;
20426 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20427 wxString *arg2 = 0 ;
20428 long arg3 ;
20429 bool result;
20430 void *argp1 = 0 ;
20431 int res1 = 0 ;
20432 bool temp2 = false ;
20433 long val3 ;
20434 int ecode3 = 0 ;
20435 PyObject * obj0 = 0 ;
20436 PyObject * obj1 = 0 ;
20437 PyObject * obj2 = 0 ;
20438 char * kwnames[] = {
20439 (char *) "self",(char *) "key",(char *) "value", NULL
20440 };
20441
20442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20444 if (!SWIG_IsOK(res1)) {
20445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteInt" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20446 }
20447 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20448 {
20449 arg2 = wxString_in_helper(obj1);
20450 if (arg2 == NULL) SWIG_fail;
20451 temp2 = true;
20452 }
20453 ecode3 = SWIG_AsVal_long(obj2, &val3);
20454 if (!SWIG_IsOK(ecode3)) {
20455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteInt" "', expected argument " "3"" of type '" "long""'");
20456 }
20457 arg3 = static_cast< long >(val3);
20458 {
20459 PyThreadState* __tstate = wxPyBeginAllowThreads();
20460 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20461 wxPyEndAllowThreads(__tstate);
20462 if (PyErr_Occurred()) SWIG_fail;
20463 }
20464 {
20465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20466 }
20467 {
20468 if (temp2)
20469 delete arg2;
20470 }
20471 return resultobj;
20472 fail:
20473 {
20474 if (temp2)
20475 delete arg2;
20476 }
20477 return NULL;
20478 }
20479
20480
20481 SWIGINTERN PyObject *_wrap_ConfigBase_WriteFloat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20482 PyObject *resultobj = 0;
20483 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20484 wxString *arg2 = 0 ;
20485 double arg3 ;
20486 bool result;
20487 void *argp1 = 0 ;
20488 int res1 = 0 ;
20489 bool temp2 = false ;
20490 double val3 ;
20491 int ecode3 = 0 ;
20492 PyObject * obj0 = 0 ;
20493 PyObject * obj1 = 0 ;
20494 PyObject * obj2 = 0 ;
20495 char * kwnames[] = {
20496 (char *) "self",(char *) "key",(char *) "value", NULL
20497 };
20498
20499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20501 if (!SWIG_IsOK(res1)) {
20502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteFloat" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20503 }
20504 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20505 {
20506 arg2 = wxString_in_helper(obj1);
20507 if (arg2 == NULL) SWIG_fail;
20508 temp2 = true;
20509 }
20510 ecode3 = SWIG_AsVal_double(obj2, &val3);
20511 if (!SWIG_IsOK(ecode3)) {
20512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteFloat" "', expected argument " "3"" of type '" "double""'");
20513 }
20514 arg3 = static_cast< double >(val3);
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20518 wxPyEndAllowThreads(__tstate);
20519 if (PyErr_Occurred()) SWIG_fail;
20520 }
20521 {
20522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20523 }
20524 {
20525 if (temp2)
20526 delete arg2;
20527 }
20528 return resultobj;
20529 fail:
20530 {
20531 if (temp2)
20532 delete arg2;
20533 }
20534 return NULL;
20535 }
20536
20537
20538 SWIGINTERN PyObject *_wrap_ConfigBase_WriteBool(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20539 PyObject *resultobj = 0;
20540 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20541 wxString *arg2 = 0 ;
20542 bool arg3 ;
20543 bool result;
20544 void *argp1 = 0 ;
20545 int res1 = 0 ;
20546 bool temp2 = false ;
20547 bool val3 ;
20548 int ecode3 = 0 ;
20549 PyObject * obj0 = 0 ;
20550 PyObject * obj1 = 0 ;
20551 PyObject * obj2 = 0 ;
20552 char * kwnames[] = {
20553 (char *) "self",(char *) "key",(char *) "value", NULL
20554 };
20555
20556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20558 if (!SWIG_IsOK(res1)) {
20559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_WriteBool" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20560 }
20561 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20562 {
20563 arg2 = wxString_in_helper(obj1);
20564 if (arg2 == NULL) SWIG_fail;
20565 temp2 = true;
20566 }
20567 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20568 if (!SWIG_IsOK(ecode3)) {
20569 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_WriteBool" "', expected argument " "3"" of type '" "bool""'");
20570 }
20571 arg3 = static_cast< bool >(val3);
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
20575 wxPyEndAllowThreads(__tstate);
20576 if (PyErr_Occurred()) SWIG_fail;
20577 }
20578 {
20579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20580 }
20581 {
20582 if (temp2)
20583 delete arg2;
20584 }
20585 return resultobj;
20586 fail:
20587 {
20588 if (temp2)
20589 delete arg2;
20590 }
20591 return NULL;
20592 }
20593
20594
20595 SWIGINTERN PyObject *_wrap_ConfigBase_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20596 PyObject *resultobj = 0;
20597 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20598 bool arg2 = (bool) false ;
20599 bool result;
20600 void *argp1 = 0 ;
20601 int res1 = 0 ;
20602 bool val2 ;
20603 int ecode2 = 0 ;
20604 PyObject * obj0 = 0 ;
20605 PyObject * obj1 = 0 ;
20606 char * kwnames[] = {
20607 (char *) "self",(char *) "currentOnly", NULL
20608 };
20609
20610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) SWIG_fail;
20611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20612 if (!SWIG_IsOK(res1)) {
20613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_Flush" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20614 }
20615 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20616 if (obj1) {
20617 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20618 if (!SWIG_IsOK(ecode2)) {
20619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_Flush" "', expected argument " "2"" of type '" "bool""'");
20620 }
20621 arg2 = static_cast< bool >(val2);
20622 }
20623 {
20624 PyThreadState* __tstate = wxPyBeginAllowThreads();
20625 result = (bool)(arg1)->Flush(arg2);
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 {
20630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20631 }
20632 return resultobj;
20633 fail:
20634 return NULL;
20635 }
20636
20637
20638 SWIGINTERN PyObject *_wrap_ConfigBase_RenameEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20639 PyObject *resultobj = 0;
20640 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20641 wxString *arg2 = 0 ;
20642 wxString *arg3 = 0 ;
20643 bool result;
20644 void *argp1 = 0 ;
20645 int res1 = 0 ;
20646 bool temp2 = false ;
20647 bool temp3 = false ;
20648 PyObject * obj0 = 0 ;
20649 PyObject * obj1 = 0 ;
20650 PyObject * obj2 = 0 ;
20651 char * kwnames[] = {
20652 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20653 };
20654
20655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20657 if (!SWIG_IsOK(res1)) {
20658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20659 }
20660 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20661 {
20662 arg2 = wxString_in_helper(obj1);
20663 if (arg2 == NULL) SWIG_fail;
20664 temp2 = true;
20665 }
20666 {
20667 arg3 = wxString_in_helper(obj2);
20668 if (arg3 == NULL) SWIG_fail;
20669 temp3 = true;
20670 }
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 {
20678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20679 }
20680 {
20681 if (temp2)
20682 delete arg2;
20683 }
20684 {
20685 if (temp3)
20686 delete arg3;
20687 }
20688 return resultobj;
20689 fail:
20690 {
20691 if (temp2)
20692 delete arg2;
20693 }
20694 {
20695 if (temp3)
20696 delete arg3;
20697 }
20698 return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_ConfigBase_RenameGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20703 PyObject *resultobj = 0;
20704 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20705 wxString *arg2 = 0 ;
20706 wxString *arg3 = 0 ;
20707 bool result;
20708 void *argp1 = 0 ;
20709 int res1 = 0 ;
20710 bool temp2 = false ;
20711 bool temp3 = false ;
20712 PyObject * obj0 = 0 ;
20713 PyObject * obj1 = 0 ;
20714 PyObject * obj2 = 0 ;
20715 char * kwnames[] = {
20716 (char *) "self",(char *) "oldName",(char *) "newName", NULL
20717 };
20718
20719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20721 if (!SWIG_IsOK(res1)) {
20722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_RenameGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20723 }
20724 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20725 {
20726 arg2 = wxString_in_helper(obj1);
20727 if (arg2 == NULL) SWIG_fail;
20728 temp2 = true;
20729 }
20730 {
20731 arg3 = wxString_in_helper(obj2);
20732 if (arg3 == NULL) SWIG_fail;
20733 temp3 = true;
20734 }
20735 {
20736 PyThreadState* __tstate = wxPyBeginAllowThreads();
20737 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
20738 wxPyEndAllowThreads(__tstate);
20739 if (PyErr_Occurred()) SWIG_fail;
20740 }
20741 {
20742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20743 }
20744 {
20745 if (temp2)
20746 delete arg2;
20747 }
20748 {
20749 if (temp3)
20750 delete arg3;
20751 }
20752 return resultobj;
20753 fail:
20754 {
20755 if (temp2)
20756 delete arg2;
20757 }
20758 {
20759 if (temp3)
20760 delete arg3;
20761 }
20762 return NULL;
20763 }
20764
20765
20766 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20767 PyObject *resultobj = 0;
20768 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20769 wxString *arg2 = 0 ;
20770 bool arg3 = (bool) true ;
20771 bool result;
20772 void *argp1 = 0 ;
20773 int res1 = 0 ;
20774 bool temp2 = false ;
20775 bool val3 ;
20776 int ecode3 = 0 ;
20777 PyObject * obj0 = 0 ;
20778 PyObject * obj1 = 0 ;
20779 PyObject * obj2 = 0 ;
20780 char * kwnames[] = {
20781 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
20782 };
20783
20784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20786 if (!SWIG_IsOK(res1)) {
20787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20788 }
20789 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20790 {
20791 arg2 = wxString_in_helper(obj1);
20792 if (arg2 == NULL) SWIG_fail;
20793 temp2 = true;
20794 }
20795 if (obj2) {
20796 ecode3 = SWIG_AsVal_bool(obj2, &val3);
20797 if (!SWIG_IsOK(ecode3)) {
20798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConfigBase_DeleteEntry" "', expected argument " "3"" of type '" "bool""'");
20799 }
20800 arg3 = static_cast< bool >(val3);
20801 }
20802 {
20803 PyThreadState* __tstate = wxPyBeginAllowThreads();
20804 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
20805 wxPyEndAllowThreads(__tstate);
20806 if (PyErr_Occurred()) SWIG_fail;
20807 }
20808 {
20809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20810 }
20811 {
20812 if (temp2)
20813 delete arg2;
20814 }
20815 return resultobj;
20816 fail:
20817 {
20818 if (temp2)
20819 delete arg2;
20820 }
20821 return NULL;
20822 }
20823
20824
20825 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20826 PyObject *resultobj = 0;
20827 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20828 wxString *arg2 = 0 ;
20829 bool result;
20830 void *argp1 = 0 ;
20831 int res1 = 0 ;
20832 bool temp2 = false ;
20833 PyObject * obj0 = 0 ;
20834 PyObject * obj1 = 0 ;
20835 char * kwnames[] = {
20836 (char *) "self",(char *) "key", NULL
20837 };
20838
20839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) SWIG_fail;
20840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20841 if (!SWIG_IsOK(res1)) {
20842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteGroup" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20843 }
20844 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20845 {
20846 arg2 = wxString_in_helper(obj1);
20847 if (arg2 == NULL) SWIG_fail;
20848 temp2 = true;
20849 }
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 {
20857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20858 }
20859 {
20860 if (temp2)
20861 delete arg2;
20862 }
20863 return resultobj;
20864 fail:
20865 {
20866 if (temp2)
20867 delete arg2;
20868 }
20869 return NULL;
20870 }
20871
20872
20873 SWIGINTERN PyObject *_wrap_ConfigBase_DeleteAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20874 PyObject *resultobj = 0;
20875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20876 bool result;
20877 void *argp1 = 0 ;
20878 int res1 = 0 ;
20879 PyObject *swig_obj[1] ;
20880
20881 if (!args) SWIG_fail;
20882 swig_obj[0] = args;
20883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20884 if (!SWIG_IsOK(res1)) {
20885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_DeleteAll" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20886 }
20887 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (bool)(arg1)->DeleteAll();
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 {
20895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20896 }
20897 return resultobj;
20898 fail:
20899 return NULL;
20900 }
20901
20902
20903 SWIGINTERN PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20904 PyObject *resultobj = 0;
20905 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20906 bool arg2 = (bool) true ;
20907 void *argp1 = 0 ;
20908 int res1 = 0 ;
20909 bool val2 ;
20910 int ecode2 = 0 ;
20911 PyObject * obj0 = 0 ;
20912 PyObject * obj1 = 0 ;
20913 char * kwnames[] = {
20914 (char *) "self",(char *) "doIt", NULL
20915 };
20916
20917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
20918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20919 if (!SWIG_IsOK(res1)) {
20920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20921 }
20922 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20923 if (obj1) {
20924 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20925 if (!SWIG_IsOK(ecode2)) {
20926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetExpandEnvVars" "', expected argument " "2"" of type '" "bool""'");
20927 }
20928 arg2 = static_cast< bool >(val2);
20929 }
20930 {
20931 PyThreadState* __tstate = wxPyBeginAllowThreads();
20932 (arg1)->SetExpandEnvVars(arg2);
20933 wxPyEndAllowThreads(__tstate);
20934 if (PyErr_Occurred()) SWIG_fail;
20935 }
20936 resultobj = SWIG_Py_Void();
20937 return resultobj;
20938 fail:
20939 return NULL;
20940 }
20941
20942
20943 SWIGINTERN PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20944 PyObject *resultobj = 0;
20945 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20946 bool result;
20947 void *argp1 = 0 ;
20948 int res1 = 0 ;
20949 PyObject *swig_obj[1] ;
20950
20951 if (!args) SWIG_fail;
20952 swig_obj[0] = args;
20953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20954 if (!SWIG_IsOK(res1)) {
20955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsExpandingEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
20956 }
20957 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20958 {
20959 PyThreadState* __tstate = wxPyBeginAllowThreads();
20960 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
20961 wxPyEndAllowThreads(__tstate);
20962 if (PyErr_Occurred()) SWIG_fail;
20963 }
20964 {
20965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20966 }
20967 return resultobj;
20968 fail:
20969 return NULL;
20970 }
20971
20972
20973 SWIGINTERN PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20974 PyObject *resultobj = 0;
20975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
20976 bool arg2 = (bool) true ;
20977 void *argp1 = 0 ;
20978 int res1 = 0 ;
20979 bool val2 ;
20980 int ecode2 = 0 ;
20981 PyObject * obj0 = 0 ;
20982 PyObject * obj1 = 0 ;
20983 char * kwnames[] = {
20984 (char *) "self",(char *) "doIt", NULL
20985 };
20986
20987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
20988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
20989 if (!SWIG_IsOK(res1)) {
20990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "1"" of type '" "wxConfigBase *""'");
20991 }
20992 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
20993 if (obj1) {
20994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20995 if (!SWIG_IsOK(ecode2)) {
20996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetRecordDefaults" "', expected argument " "2"" of type '" "bool""'");
20997 }
20998 arg2 = static_cast< bool >(val2);
20999 }
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 (arg1)->SetRecordDefaults(arg2);
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 resultobj = SWIG_Py_Void();
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 SWIGINTERN PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21014 PyObject *resultobj = 0;
21015 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21016 bool result;
21017 void *argp1 = 0 ;
21018 int res1 = 0 ;
21019 PyObject *swig_obj[1] ;
21020
21021 if (!args) SWIG_fail;
21022 swig_obj[0] = args;
21023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21024 if (!SWIG_IsOK(res1)) {
21025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_IsRecordingDefaults" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21026 }
21027 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 {
21035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21036 }
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 SWIGINTERN PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21044 PyObject *resultobj = 0;
21045 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21046 wxString *arg2 = 0 ;
21047 wxString result;
21048 void *argp1 = 0 ;
21049 int res1 = 0 ;
21050 bool temp2 = false ;
21051 PyObject * obj0 = 0 ;
21052 PyObject * obj1 = 0 ;
21053 char * kwnames[] = {
21054 (char *) "self",(char *) "str", NULL
21055 };
21056
21057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) SWIG_fail;
21058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21059 if (!SWIG_IsOK(res1)) {
21060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_ExpandEnvVars" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21061 }
21062 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21063 {
21064 arg2 = wxString_in_helper(obj1);
21065 if (arg2 == NULL) SWIG_fail;
21066 temp2 = true;
21067 }
21068 {
21069 PyThreadState* __tstate = wxPyBeginAllowThreads();
21070 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
21071 wxPyEndAllowThreads(__tstate);
21072 if (PyErr_Occurred()) SWIG_fail;
21073 }
21074 {
21075 #if wxUSE_UNICODE
21076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21077 #else
21078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21079 #endif
21080 }
21081 {
21082 if (temp2)
21083 delete arg2;
21084 }
21085 return resultobj;
21086 fail:
21087 {
21088 if (temp2)
21089 delete arg2;
21090 }
21091 return NULL;
21092 }
21093
21094
21095 SWIGINTERN PyObject *_wrap_ConfigBase_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21096 PyObject *resultobj = 0;
21097 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21098 wxString result;
21099 void *argp1 = 0 ;
21100 int res1 = 0 ;
21101 PyObject *swig_obj[1] ;
21102
21103 if (!args) SWIG_fail;
21104 swig_obj[0] = args;
21105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21106 if (!SWIG_IsOK(res1)) {
21107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetAppName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21108 }
21109 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21110 {
21111 PyThreadState* __tstate = wxPyBeginAllowThreads();
21112 result = ((wxConfigBase const *)arg1)->GetAppName();
21113 wxPyEndAllowThreads(__tstate);
21114 if (PyErr_Occurred()) SWIG_fail;
21115 }
21116 {
21117 #if wxUSE_UNICODE
21118 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21119 #else
21120 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21121 #endif
21122 }
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 SWIGINTERN PyObject *_wrap_ConfigBase_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 PyObject *resultobj = 0;
21131 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21132 wxString result;
21133 void *argp1 = 0 ;
21134 int res1 = 0 ;
21135 PyObject *swig_obj[1] ;
21136
21137 if (!args) SWIG_fail;
21138 swig_obj[0] = args;
21139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21140 if (!SWIG_IsOK(res1)) {
21141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetVendorName" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21142 }
21143 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21144 {
21145 PyThreadState* __tstate = wxPyBeginAllowThreads();
21146 result = ((wxConfigBase const *)arg1)->GetVendorName();
21147 wxPyEndAllowThreads(__tstate);
21148 if (PyErr_Occurred()) SWIG_fail;
21149 }
21150 {
21151 #if wxUSE_UNICODE
21152 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21153 #else
21154 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21155 #endif
21156 }
21157 return resultobj;
21158 fail:
21159 return NULL;
21160 }
21161
21162
21163 SWIGINTERN PyObject *_wrap_ConfigBase_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21164 PyObject *resultobj = 0;
21165 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21166 wxString *arg2 = 0 ;
21167 void *argp1 = 0 ;
21168 int res1 = 0 ;
21169 bool temp2 = false ;
21170 PyObject * obj0 = 0 ;
21171 PyObject * obj1 = 0 ;
21172 char * kwnames[] = {
21173 (char *) "self",(char *) "appName", NULL
21174 };
21175
21176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
21177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21178 if (!SWIG_IsOK(res1)) {
21179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetAppName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21180 }
21181 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21182 {
21183 arg2 = wxString_in_helper(obj1);
21184 if (arg2 == NULL) SWIG_fail;
21185 temp2 = true;
21186 }
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 (arg1)->SetAppName((wxString const &)*arg2);
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 resultobj = SWIG_Py_Void();
21194 {
21195 if (temp2)
21196 delete arg2;
21197 }
21198 return resultobj;
21199 fail:
21200 {
21201 if (temp2)
21202 delete arg2;
21203 }
21204 return NULL;
21205 }
21206
21207
21208 SWIGINTERN PyObject *_wrap_ConfigBase_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21209 PyObject *resultobj = 0;
21210 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21211 wxString *arg2 = 0 ;
21212 void *argp1 = 0 ;
21213 int res1 = 0 ;
21214 bool temp2 = false ;
21215 PyObject * obj0 = 0 ;
21216 PyObject * obj1 = 0 ;
21217 char * kwnames[] = {
21218 (char *) "self",(char *) "vendorName", NULL
21219 };
21220
21221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
21222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21223 if (!SWIG_IsOK(res1)) {
21224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetVendorName" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21225 }
21226 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21227 {
21228 arg2 = wxString_in_helper(obj1);
21229 if (arg2 == NULL) SWIG_fail;
21230 temp2 = true;
21231 }
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 (arg1)->SetVendorName((wxString const &)*arg2);
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 resultobj = SWIG_Py_Void();
21239 {
21240 if (temp2)
21241 delete arg2;
21242 }
21243 return resultobj;
21244 fail:
21245 {
21246 if (temp2)
21247 delete arg2;
21248 }
21249 return NULL;
21250 }
21251
21252
21253 SWIGINTERN PyObject *_wrap_ConfigBase_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21254 PyObject *resultobj = 0;
21255 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21256 long arg2 ;
21257 void *argp1 = 0 ;
21258 int res1 = 0 ;
21259 long val2 ;
21260 int ecode2 = 0 ;
21261 PyObject * obj0 = 0 ;
21262 PyObject * obj1 = 0 ;
21263 char * kwnames[] = {
21264 (char *) "self",(char *) "style", NULL
21265 };
21266
21267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) SWIG_fail;
21268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_SetStyle" "', expected argument " "1"" of type '" "wxConfigBase *""'");
21271 }
21272 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21273 ecode2 = SWIG_AsVal_long(obj1, &val2);
21274 if (!SWIG_IsOK(ecode2)) {
21275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConfigBase_SetStyle" "', expected argument " "2"" of type '" "long""'");
21276 }
21277 arg2 = static_cast< long >(val2);
21278 {
21279 PyThreadState* __tstate = wxPyBeginAllowThreads();
21280 (arg1)->SetStyle(arg2);
21281 wxPyEndAllowThreads(__tstate);
21282 if (PyErr_Occurred()) SWIG_fail;
21283 }
21284 resultobj = SWIG_Py_Void();
21285 return resultobj;
21286 fail:
21287 return NULL;
21288 }
21289
21290
21291 SWIGINTERN PyObject *_wrap_ConfigBase_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21292 PyObject *resultobj = 0;
21293 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21294 long result;
21295 void *argp1 = 0 ;
21296 int res1 = 0 ;
21297 PyObject *swig_obj[1] ;
21298
21299 if (!args) SWIG_fail;
21300 swig_obj[0] = args;
21301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21302 if (!SWIG_IsOK(res1)) {
21303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigBase_GetStyle" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21304 }
21305 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21306 {
21307 PyThreadState* __tstate = wxPyBeginAllowThreads();
21308 result = (long)((wxConfigBase const *)arg1)->GetStyle();
21309 wxPyEndAllowThreads(__tstate);
21310 if (PyErr_Occurred()) SWIG_fail;
21311 }
21312 resultobj = SWIG_From_long(static_cast< long >(result));
21313 return resultobj;
21314 fail:
21315 return NULL;
21316 }
21317
21318
21319 SWIGINTERN PyObject *ConfigBase_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21320 PyObject *obj;
21321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21322 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigBase, SWIG_NewClientData(obj));
21323 return SWIG_Py_Void();
21324 }
21325
21326 SWIGINTERN PyObject *_wrap_new_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21327 PyObject *resultobj = 0;
21328 wxString const &arg1_defvalue = wxPyEmptyString ;
21329 wxString *arg1 = (wxString *) &arg1_defvalue ;
21330 wxString const &arg2_defvalue = wxPyEmptyString ;
21331 wxString *arg2 = (wxString *) &arg2_defvalue ;
21332 wxString const &arg3_defvalue = wxPyEmptyString ;
21333 wxString *arg3 = (wxString *) &arg3_defvalue ;
21334 wxString const &arg4_defvalue = wxPyEmptyString ;
21335 wxString *arg4 = (wxString *) &arg4_defvalue ;
21336 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21337 wxConfig *result = 0 ;
21338 bool temp1 = false ;
21339 bool temp2 = false ;
21340 bool temp3 = false ;
21341 bool temp4 = false ;
21342 long val5 ;
21343 int ecode5 = 0 ;
21344 PyObject * obj0 = 0 ;
21345 PyObject * obj1 = 0 ;
21346 PyObject * obj2 = 0 ;
21347 PyObject * obj3 = 0 ;
21348 PyObject * obj4 = 0 ;
21349 char * kwnames[] = {
21350 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21351 };
21352
21353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21354 if (obj0) {
21355 {
21356 arg1 = wxString_in_helper(obj0);
21357 if (arg1 == NULL) SWIG_fail;
21358 temp1 = true;
21359 }
21360 }
21361 if (obj1) {
21362 {
21363 arg2 = wxString_in_helper(obj1);
21364 if (arg2 == NULL) SWIG_fail;
21365 temp2 = true;
21366 }
21367 }
21368 if (obj2) {
21369 {
21370 arg3 = wxString_in_helper(obj2);
21371 if (arg3 == NULL) SWIG_fail;
21372 temp3 = true;
21373 }
21374 }
21375 if (obj3) {
21376 {
21377 arg4 = wxString_in_helper(obj3);
21378 if (arg4 == NULL) SWIG_fail;
21379 temp4 = true;
21380 }
21381 }
21382 if (obj4) {
21383 ecode5 = SWIG_AsVal_long(obj4, &val5);
21384 if (!SWIG_IsOK(ecode5)) {
21385 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Config" "', expected argument " "5"" of type '" "long""'");
21386 }
21387 arg5 = static_cast< long >(val5);
21388 }
21389 {
21390 PyThreadState* __tstate = wxPyBeginAllowThreads();
21391 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21392 wxPyEndAllowThreads(__tstate);
21393 if (PyErr_Occurred()) SWIG_fail;
21394 }
21395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfig, SWIG_POINTER_NEW | 0 );
21396 {
21397 if (temp1)
21398 delete arg1;
21399 }
21400 {
21401 if (temp2)
21402 delete arg2;
21403 }
21404 {
21405 if (temp3)
21406 delete arg3;
21407 }
21408 {
21409 if (temp4)
21410 delete arg4;
21411 }
21412 return resultobj;
21413 fail:
21414 {
21415 if (temp1)
21416 delete arg1;
21417 }
21418 {
21419 if (temp2)
21420 delete arg2;
21421 }
21422 {
21423 if (temp3)
21424 delete arg3;
21425 }
21426 {
21427 if (temp4)
21428 delete arg4;
21429 }
21430 return NULL;
21431 }
21432
21433
21434 SWIGINTERN PyObject *_wrap_delete_Config(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21435 PyObject *resultobj = 0;
21436 wxConfig *arg1 = (wxConfig *) 0 ;
21437 void *argp1 = 0 ;
21438 int res1 = 0 ;
21439 PyObject *swig_obj[1] ;
21440
21441 if (!args) SWIG_fail;
21442 swig_obj[0] = args;
21443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfig, SWIG_POINTER_DISOWN | 0 );
21444 if (!SWIG_IsOK(res1)) {
21445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Config" "', expected argument " "1"" of type '" "wxConfig *""'");
21446 }
21447 arg1 = reinterpret_cast< wxConfig * >(argp1);
21448 {
21449 PyThreadState* __tstate = wxPyBeginAllowThreads();
21450 delete arg1;
21451
21452 wxPyEndAllowThreads(__tstate);
21453 if (PyErr_Occurred()) SWIG_fail;
21454 }
21455 resultobj = SWIG_Py_Void();
21456 return resultobj;
21457 fail:
21458 return NULL;
21459 }
21460
21461
21462 SWIGINTERN PyObject *Config_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21463 PyObject *obj;
21464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21465 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfig, SWIG_NewClientData(obj));
21466 return SWIG_Py_Void();
21467 }
21468
21469 SWIGINTERN PyObject *Config_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21470 return SWIG_Python_InitShadowInstance(args);
21471 }
21472
21473 SWIGINTERN PyObject *_wrap_new_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21474 PyObject *resultobj = 0;
21475 wxString const &arg1_defvalue = wxPyEmptyString ;
21476 wxString *arg1 = (wxString *) &arg1_defvalue ;
21477 wxString const &arg2_defvalue = wxPyEmptyString ;
21478 wxString *arg2 = (wxString *) &arg2_defvalue ;
21479 wxString const &arg3_defvalue = wxPyEmptyString ;
21480 wxString *arg3 = (wxString *) &arg3_defvalue ;
21481 wxString const &arg4_defvalue = wxPyEmptyString ;
21482 wxString *arg4 = (wxString *) &arg4_defvalue ;
21483 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
21484 wxFileConfig *result = 0 ;
21485 bool temp1 = false ;
21486 bool temp2 = false ;
21487 bool temp3 = false ;
21488 bool temp4 = false ;
21489 long val5 ;
21490 int ecode5 = 0 ;
21491 PyObject * obj0 = 0 ;
21492 PyObject * obj1 = 0 ;
21493 PyObject * obj2 = 0 ;
21494 PyObject * obj3 = 0 ;
21495 PyObject * obj4 = 0 ;
21496 char * kwnames[] = {
21497 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
21498 };
21499
21500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21501 if (obj0) {
21502 {
21503 arg1 = wxString_in_helper(obj0);
21504 if (arg1 == NULL) SWIG_fail;
21505 temp1 = true;
21506 }
21507 }
21508 if (obj1) {
21509 {
21510 arg2 = wxString_in_helper(obj1);
21511 if (arg2 == NULL) SWIG_fail;
21512 temp2 = true;
21513 }
21514 }
21515 if (obj2) {
21516 {
21517 arg3 = wxString_in_helper(obj2);
21518 if (arg3 == NULL) SWIG_fail;
21519 temp3 = true;
21520 }
21521 }
21522 if (obj3) {
21523 {
21524 arg4 = wxString_in_helper(obj3);
21525 if (arg4 == NULL) SWIG_fail;
21526 temp4 = true;
21527 }
21528 }
21529 if (obj4) {
21530 ecode5 = SWIG_AsVal_long(obj4, &val5);
21531 if (!SWIG_IsOK(ecode5)) {
21532 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FileConfig" "', expected argument " "5"" of type '" "long""'");
21533 }
21534 arg5 = static_cast< long >(val5);
21535 }
21536 {
21537 PyThreadState* __tstate = wxPyBeginAllowThreads();
21538 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
21539 wxPyEndAllowThreads(__tstate);
21540 if (PyErr_Occurred()) SWIG_fail;
21541 }
21542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileConfig, SWIG_POINTER_NEW | 0 );
21543 {
21544 if (temp1)
21545 delete arg1;
21546 }
21547 {
21548 if (temp2)
21549 delete arg2;
21550 }
21551 {
21552 if (temp3)
21553 delete arg3;
21554 }
21555 {
21556 if (temp4)
21557 delete arg4;
21558 }
21559 return resultobj;
21560 fail:
21561 {
21562 if (temp1)
21563 delete arg1;
21564 }
21565 {
21566 if (temp2)
21567 delete arg2;
21568 }
21569 {
21570 if (temp3)
21571 delete arg3;
21572 }
21573 {
21574 if (temp4)
21575 delete arg4;
21576 }
21577 return NULL;
21578 }
21579
21580
21581 SWIGINTERN PyObject *_wrap_delete_FileConfig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21582 PyObject *resultobj = 0;
21583 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
21584 void *argp1 = 0 ;
21585 int res1 = 0 ;
21586 PyObject *swig_obj[1] ;
21587
21588 if (!args) SWIG_fail;
21589 swig_obj[0] = args;
21590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileConfig, SWIG_POINTER_DISOWN | 0 );
21591 if (!SWIG_IsOK(res1)) {
21592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileConfig" "', expected argument " "1"" of type '" "wxFileConfig *""'");
21593 }
21594 arg1 = reinterpret_cast< wxFileConfig * >(argp1);
21595 {
21596 PyThreadState* __tstate = wxPyBeginAllowThreads();
21597 delete arg1;
21598
21599 wxPyEndAllowThreads(__tstate);
21600 if (PyErr_Occurred()) SWIG_fail;
21601 }
21602 resultobj = SWIG_Py_Void();
21603 return resultobj;
21604 fail:
21605 return NULL;
21606 }
21607
21608
21609 SWIGINTERN PyObject *FileConfig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21610 PyObject *obj;
21611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21612 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileConfig, SWIG_NewClientData(obj));
21613 return SWIG_Py_Void();
21614 }
21615
21616 SWIGINTERN PyObject *FileConfig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617 return SWIG_Python_InitShadowInstance(args);
21618 }
21619
21620 SWIGINTERN PyObject *_wrap_new_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21621 PyObject *resultobj = 0;
21622 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
21623 wxString *arg2 = 0 ;
21624 wxConfigPathChanger *result = 0 ;
21625 void *argp1 = 0 ;
21626 int res1 = 0 ;
21627 bool temp2 = false ;
21628 PyObject * obj0 = 0 ;
21629 PyObject * obj1 = 0 ;
21630 char * kwnames[] = {
21631 (char *) "config",(char *) "entry", NULL
21632 };
21633
21634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) SWIG_fail;
21635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxConfigBase, 0 | 0 );
21636 if (!SWIG_IsOK(res1)) {
21637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigBase const *""'");
21638 }
21639 arg1 = reinterpret_cast< wxConfigBase * >(argp1);
21640 {
21641 arg2 = wxString_in_helper(obj1);
21642 if (arg2 == NULL) SWIG_fail;
21643 temp2 = true;
21644 }
21645 {
21646 PyThreadState* __tstate = wxPyBeginAllowThreads();
21647 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
21648 wxPyEndAllowThreads(__tstate);
21649 if (PyErr_Occurred()) SWIG_fail;
21650 }
21651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_NEW | 0 );
21652 {
21653 if (temp2)
21654 delete arg2;
21655 }
21656 return resultobj;
21657 fail:
21658 {
21659 if (temp2)
21660 delete arg2;
21661 }
21662 return NULL;
21663 }
21664
21665
21666 SWIGINTERN PyObject *_wrap_delete_ConfigPathChanger(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 PyObject *resultobj = 0;
21668 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21669 void *argp1 = 0 ;
21670 int res1 = 0 ;
21671 PyObject *swig_obj[1] ;
21672
21673 if (!args) SWIG_fail;
21674 swig_obj[0] = args;
21675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_DISOWN | 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConfigPathChanger" "', expected argument " "1"" of type '" "wxConfigPathChanger *""'");
21678 }
21679 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21680 {
21681 PyThreadState* __tstate = wxPyBeginAllowThreads();
21682 delete arg1;
21683
21684 wxPyEndAllowThreads(__tstate);
21685 if (PyErr_Occurred()) SWIG_fail;
21686 }
21687 resultobj = SWIG_Py_Void();
21688 return resultobj;
21689 fail:
21690 return NULL;
21691 }
21692
21693
21694 SWIGINTERN PyObject *_wrap_ConfigPathChanger_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21695 PyObject *resultobj = 0;
21696 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
21697 wxString *result = 0 ;
21698 void *argp1 = 0 ;
21699 int res1 = 0 ;
21700 PyObject *swig_obj[1] ;
21701
21702 if (!args) SWIG_fail;
21703 swig_obj[0] = args;
21704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxConfigPathChanger, 0 | 0 );
21705 if (!SWIG_IsOK(res1)) {
21706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConfigPathChanger_Name" "', expected argument " "1"" of type '" "wxConfigPathChanger const *""'");
21707 }
21708 arg1 = reinterpret_cast< wxConfigPathChanger * >(argp1);
21709 {
21710 PyThreadState* __tstate = wxPyBeginAllowThreads();
21711 {
21712 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
21713 result = (wxString *) &_result_ref;
21714 }
21715 wxPyEndAllowThreads(__tstate);
21716 if (PyErr_Occurred()) SWIG_fail;
21717 }
21718 {
21719 #if wxUSE_UNICODE
21720 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
21721 #else
21722 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
21723 #endif
21724 }
21725 return resultobj;
21726 fail:
21727 return NULL;
21728 }
21729
21730
21731 SWIGINTERN PyObject *ConfigPathChanger_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21732 PyObject *obj;
21733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21734 SWIG_TypeNewClientData(SWIGTYPE_p_wxConfigPathChanger, SWIG_NewClientData(obj));
21735 return SWIG_Py_Void();
21736 }
21737
21738 SWIGINTERN PyObject *ConfigPathChanger_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21739 return SWIG_Python_InitShadowInstance(args);
21740 }
21741
21742 SWIGINTERN PyObject *_wrap_ExpandEnvVars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21743 PyObject *resultobj = 0;
21744 wxString *arg1 = 0 ;
21745 wxString result;
21746 bool temp1 = false ;
21747 PyObject * obj0 = 0 ;
21748 char * kwnames[] = {
21749 (char *) "sz", NULL
21750 };
21751
21752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) SWIG_fail;
21753 {
21754 arg1 = wxString_in_helper(obj0);
21755 if (arg1 == NULL) SWIG_fail;
21756 temp1 = true;
21757 }
21758 {
21759 PyThreadState* __tstate = wxPyBeginAllowThreads();
21760 result = wxExpandEnvVars((wxString const &)*arg1);
21761 wxPyEndAllowThreads(__tstate);
21762 if (PyErr_Occurred()) SWIG_fail;
21763 }
21764 {
21765 #if wxUSE_UNICODE
21766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21767 #else
21768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21769 #endif
21770 }
21771 {
21772 if (temp1)
21773 delete arg1;
21774 }
21775 return resultobj;
21776 fail:
21777 {
21778 if (temp1)
21779 delete arg1;
21780 }
21781 return NULL;
21782 }
21783
21784
21785 SWIGINTERN int DefaultDateTimeFormat_set(PyObject *) {
21786 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTimeFormat is read-only.");
21787 return 1;
21788 }
21789
21790
21791 SWIGINTERN PyObject *DefaultDateTimeFormat_get(void) {
21792 PyObject *pyobj = 0;
21793
21794 {
21795 #if wxUSE_UNICODE
21796 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21797 #else
21798 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
21799 #endif
21800 }
21801 return pyobj;
21802 }
21803
21804
21805 SWIGINTERN int DefaultTimeSpanFormat_set(PyObject *) {
21806 SWIG_Error(SWIG_AttributeError,"Variable DefaultTimeSpanFormat is read-only.");
21807 return 1;
21808 }
21809
21810
21811 SWIGINTERN PyObject *DefaultTimeSpanFormat_get(void) {
21812 PyObject *pyobj = 0;
21813
21814 {
21815 #if wxUSE_UNICODE
21816 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21817 #else
21818 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
21819 #endif
21820 }
21821 return pyobj;
21822 }
21823
21824
21825 SWIGINTERN PyObject *_wrap_DateTime_SetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21826 PyObject *resultobj = 0;
21827 wxDateTime::Country arg1 ;
21828 int val1 ;
21829 int ecode1 = 0 ;
21830 PyObject * obj0 = 0 ;
21831 char * kwnames[] = {
21832 (char *) "country", NULL
21833 };
21834
21835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) SWIG_fail;
21836 ecode1 = SWIG_AsVal_int(obj0, &val1);
21837 if (!SWIG_IsOK(ecode1)) {
21838 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21839 }
21840 arg1 = static_cast< wxDateTime::Country >(val1);
21841 {
21842 PyThreadState* __tstate = wxPyBeginAllowThreads();
21843 wxDateTime::SetCountry(arg1);
21844 wxPyEndAllowThreads(__tstate);
21845 if (PyErr_Occurred()) SWIG_fail;
21846 }
21847 resultobj = SWIG_Py_Void();
21848 return resultobj;
21849 fail:
21850 return NULL;
21851 }
21852
21853
21854 SWIGINTERN PyObject *_wrap_DateTime_GetCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21855 PyObject *resultobj = 0;
21856 wxDateTime::Country result;
21857
21858 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetCountry",0,0,0)) SWIG_fail;
21859 {
21860 PyThreadState* __tstate = wxPyBeginAllowThreads();
21861 result = (wxDateTime::Country)wxDateTime::GetCountry();
21862 wxPyEndAllowThreads(__tstate);
21863 if (PyErr_Occurred()) SWIG_fail;
21864 }
21865 resultobj = SWIG_From_int(static_cast< int >(result));
21866 return resultobj;
21867 fail:
21868 return NULL;
21869 }
21870
21871
21872 SWIGINTERN PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21873 PyObject *resultobj = 0;
21874 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
21875 bool result;
21876 int val1 ;
21877 int ecode1 = 0 ;
21878 PyObject * obj0 = 0 ;
21879 char * kwnames[] = {
21880 (char *) "country", NULL
21881 };
21882
21883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) SWIG_fail;
21884 if (obj0) {
21885 ecode1 = SWIG_AsVal_int(obj0, &val1);
21886 if (!SWIG_IsOK(ecode1)) {
21887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsWestEuropeanCountry" "', expected argument " "1"" of type '" "wxDateTime::Country""'");
21888 }
21889 arg1 = static_cast< wxDateTime::Country >(val1);
21890 }
21891 {
21892 PyThreadState* __tstate = wxPyBeginAllowThreads();
21893 result = (bool)wxDateTime::IsWestEuropeanCountry(arg1);
21894 wxPyEndAllowThreads(__tstate);
21895 if (PyErr_Occurred()) SWIG_fail;
21896 }
21897 {
21898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21899 }
21900 return resultobj;
21901 fail:
21902 return NULL;
21903 }
21904
21905
21906 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21907 PyObject *resultobj = 0;
21908 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21909 int result;
21910 int val1 ;
21911 int ecode1 = 0 ;
21912 PyObject * obj0 = 0 ;
21913 char * kwnames[] = {
21914 (char *) "cal", NULL
21915 };
21916
21917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) SWIG_fail;
21918 if (obj0) {
21919 ecode1 = SWIG_AsVal_int(obj0, &val1);
21920 if (!SWIG_IsOK(ecode1)) {
21921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentYear" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21922 }
21923 arg1 = static_cast< wxDateTime::Calendar >(val1);
21924 }
21925 {
21926 PyThreadState* __tstate = wxPyBeginAllowThreads();
21927 result = (int)wxDateTime::GetCurrentYear(arg1);
21928 wxPyEndAllowThreads(__tstate);
21929 if (PyErr_Occurred()) SWIG_fail;
21930 }
21931 resultobj = SWIG_From_int(static_cast< int >(result));
21932 return resultobj;
21933 fail:
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21939 PyObject *resultobj = 0;
21940 int arg1 ;
21941 int result;
21942 int val1 ;
21943 int ecode1 = 0 ;
21944 PyObject * obj0 = 0 ;
21945 char * kwnames[] = {
21946 (char *) "year", NULL
21947 };
21948
21949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) SWIG_fail;
21950 ecode1 = SWIG_AsVal_int(obj0, &val1);
21951 if (!SWIG_IsOK(ecode1)) {
21952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_ConvertYearToBC" "', expected argument " "1"" of type '" "int""'");
21953 }
21954 arg1 = static_cast< int >(val1);
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = (int)wxDateTime::ConvertYearToBC(arg1);
21958 wxPyEndAllowThreads(__tstate);
21959 if (PyErr_Occurred()) SWIG_fail;
21960 }
21961 resultobj = SWIG_From_int(static_cast< int >(result));
21962 return resultobj;
21963 fail:
21964 return NULL;
21965 }
21966
21967
21968 SWIGINTERN PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21969 PyObject *resultobj = 0;
21970 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
21971 wxDateTime::Month result;
21972 int val1 ;
21973 int ecode1 = 0 ;
21974 PyObject * obj0 = 0 ;
21975 char * kwnames[] = {
21976 (char *) "cal", NULL
21977 };
21978
21979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) SWIG_fail;
21980 if (obj0) {
21981 ecode1 = SWIG_AsVal_int(obj0, &val1);
21982 if (!SWIG_IsOK(ecode1)) {
21983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCurrentMonth" "', expected argument " "1"" of type '" "wxDateTime::Calendar""'");
21984 }
21985 arg1 = static_cast< wxDateTime::Calendar >(val1);
21986 }
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth(arg1);
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 resultobj = SWIG_From_int(static_cast< int >(result));
21994 return resultobj;
21995 fail:
21996 return NULL;
21997 }
21998
21999
22000 SWIGINTERN PyObject *_wrap_DateTime_IsLeapYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22001 PyObject *resultobj = 0;
22002 int arg1 = (int) wxDateTime::Inv_Year ;
22003 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22004 bool result;
22005 int val1 ;
22006 int ecode1 = 0 ;
22007 int val2 ;
22008 int ecode2 = 0 ;
22009 PyObject * obj0 = 0 ;
22010 PyObject * obj1 = 0 ;
22011 char * kwnames[] = {
22012 (char *) "year",(char *) "cal", NULL
22013 };
22014
22015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) SWIG_fail;
22016 if (obj0) {
22017 ecode1 = SWIG_AsVal_int(obj0, &val1);
22018 if (!SWIG_IsOK(ecode1)) {
22019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsLeapYear" "', expected argument " "1"" of type '" "int""'");
22020 }
22021 arg1 = static_cast< int >(val1);
22022 }
22023 if (obj1) {
22024 ecode2 = SWIG_AsVal_int(obj1, &val2);
22025 if (!SWIG_IsOK(ecode2)) {
22026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsLeapYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22027 }
22028 arg2 = static_cast< wxDateTime::Calendar >(val2);
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (bool)wxDateTime::IsLeapYear(arg1,arg2);
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 {
22037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22038 }
22039 return resultobj;
22040 fail:
22041 return NULL;
22042 }
22043
22044
22045 SWIGINTERN PyObject *_wrap_DateTime_GetCentury(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22046 PyObject *resultobj = 0;
22047 int arg1 = (int) wxDateTime::Inv_Year ;
22048 int result;
22049 int val1 ;
22050 int ecode1 = 0 ;
22051 PyObject * obj0 = 0 ;
22052 char * kwnames[] = {
22053 (char *) "year", NULL
22054 };
22055
22056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) SWIG_fail;
22057 if (obj0) {
22058 ecode1 = SWIG_AsVal_int(obj0, &val1);
22059 if (!SWIG_IsOK(ecode1)) {
22060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetCentury" "', expected argument " "1"" of type '" "int""'");
22061 }
22062 arg1 = static_cast< int >(val1);
22063 }
22064 {
22065 PyThreadState* __tstate = wxPyBeginAllowThreads();
22066 result = (int)wxDateTime::GetCentury(arg1);
22067 wxPyEndAllowThreads(__tstate);
22068 if (PyErr_Occurred()) SWIG_fail;
22069 }
22070 resultobj = SWIG_From_int(static_cast< int >(result));
22071 return resultobj;
22072 fail:
22073 return NULL;
22074 }
22075
22076
22077 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22078 PyObject *resultobj = 0;
22079 int arg1 ;
22080 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22081 int result;
22082 int val1 ;
22083 int ecode1 = 0 ;
22084 int val2 ;
22085 int ecode2 = 0 ;
22086 PyObject * obj0 = 0 ;
22087 PyObject * obj1 = 0 ;
22088 char * kwnames[] = {
22089 (char *) "year",(char *) "cal", NULL
22090 };
22091
22092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) SWIG_fail;
22093 ecode1 = SWIG_AsVal_int(obj0, &val1);
22094 if (!SWIG_IsOK(ecode1)) {
22095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "1"" of type '" "int""'");
22096 }
22097 arg1 = static_cast< int >(val1);
22098 if (obj1) {
22099 ecode2 = SWIG_AsVal_int(obj1, &val2);
22100 if (!SWIG_IsOK(ecode2)) {
22101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysinYear" "', expected argument " "2"" of type '" "wxDateTime::Calendar""'");
22102 }
22103 arg2 = static_cast< wxDateTime::Calendar >(val2);
22104 }
22105 {
22106 PyThreadState* __tstate = wxPyBeginAllowThreads();
22107 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2);
22108 wxPyEndAllowThreads(__tstate);
22109 if (PyErr_Occurred()) SWIG_fail;
22110 }
22111 resultobj = SWIG_From_int(static_cast< int >(result));
22112 return resultobj;
22113 fail:
22114 return NULL;
22115 }
22116
22117
22118 SWIGINTERN PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22119 PyObject *resultobj = 0;
22120 wxDateTime::Month arg1 ;
22121 int arg2 = (int) wxDateTime::Inv_Year ;
22122 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
22123 int result;
22124 int val1 ;
22125 int ecode1 = 0 ;
22126 int val2 ;
22127 int ecode2 = 0 ;
22128 int val3 ;
22129 int ecode3 = 0 ;
22130 PyObject * obj0 = 0 ;
22131 PyObject * obj1 = 0 ;
22132 PyObject * obj2 = 0 ;
22133 char * kwnames[] = {
22134 (char *) "month",(char *) "year",(char *) "cal", NULL
22135 };
22136
22137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22138 ecode1 = SWIG_AsVal_int(obj0, &val1);
22139 if (!SWIG_IsOK(ecode1)) {
22140 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22141 }
22142 arg1 = static_cast< wxDateTime::Month >(val1);
22143 if (obj1) {
22144 ecode2 = SWIG_AsVal_int(obj1, &val2);
22145 if (!SWIG_IsOK(ecode2)) {
22146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "2"" of type '" "int""'");
22147 }
22148 arg2 = static_cast< int >(val2);
22149 }
22150 if (obj2) {
22151 ecode3 = SWIG_AsVal_int(obj2, &val3);
22152 if (!SWIG_IsOK(ecode3)) {
22153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetNumberOfDaysInMonth" "', expected argument " "3"" of type '" "wxDateTime::Calendar""'");
22154 }
22155 arg3 = static_cast< wxDateTime::Calendar >(val3);
22156 }
22157 {
22158 PyThreadState* __tstate = wxPyBeginAllowThreads();
22159 result = (int)wxDateTime::GetNumberOfDays(arg1,arg2,arg3);
22160 wxPyEndAllowThreads(__tstate);
22161 if (PyErr_Occurred()) SWIG_fail;
22162 }
22163 resultobj = SWIG_From_int(static_cast< int >(result));
22164 return resultobj;
22165 fail:
22166 return NULL;
22167 }
22168
22169
22170 SWIGINTERN PyObject *_wrap_DateTime_GetMonthName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22171 PyObject *resultobj = 0;
22172 wxDateTime::Month arg1 ;
22173 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22174 wxString result;
22175 int val1 ;
22176 int ecode1 = 0 ;
22177 int val2 ;
22178 int ecode2 = 0 ;
22179 PyObject * obj0 = 0 ;
22180 PyObject * obj1 = 0 ;
22181 char * kwnames[] = {
22182 (char *) "month",(char *) "flags", NULL
22183 };
22184
22185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) SWIG_fail;
22186 ecode1 = SWIG_AsVal_int(obj0, &val1);
22187 if (!SWIG_IsOK(ecode1)) {
22188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetMonthName" "', expected argument " "1"" of type '" "wxDateTime::Month""'");
22189 }
22190 arg1 = static_cast< wxDateTime::Month >(val1);
22191 if (obj1) {
22192 ecode2 = SWIG_AsVal_int(obj1, &val2);
22193 if (!SWIG_IsOK(ecode2)) {
22194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetMonthName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22195 }
22196 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22197 }
22198 {
22199 PyThreadState* __tstate = wxPyBeginAllowThreads();
22200 result = wxDateTime::GetMonthName(arg1,arg2);
22201 wxPyEndAllowThreads(__tstate);
22202 if (PyErr_Occurred()) SWIG_fail;
22203 }
22204 {
22205 #if wxUSE_UNICODE
22206 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22207 #else
22208 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22209 #endif
22210 }
22211 return resultobj;
22212 fail:
22213 return NULL;
22214 }
22215
22216
22217 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22218 PyObject *resultobj = 0;
22219 wxDateTime::WeekDay arg1 ;
22220 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
22221 wxString result;
22222 int val1 ;
22223 int ecode1 = 0 ;
22224 int val2 ;
22225 int ecode2 = 0 ;
22226 PyObject * obj0 = 0 ;
22227 PyObject * obj1 = 0 ;
22228 char * kwnames[] = {
22229 (char *) "weekday",(char *) "flags", NULL
22230 };
22231
22232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) SWIG_fail;
22233 ecode1 = SWIG_AsVal_int(obj0, &val1);
22234 if (!SWIG_IsOK(ecode1)) {
22235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetWeekDayName" "', expected argument " "1"" of type '" "wxDateTime::WeekDay""'");
22236 }
22237 arg1 = static_cast< wxDateTime::WeekDay >(val1);
22238 if (obj1) {
22239 ecode2 = SWIG_AsVal_int(obj1, &val2);
22240 if (!SWIG_IsOK(ecode2)) {
22241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayName" "', expected argument " "2"" of type '" "wxDateTime::NameFlags""'");
22242 }
22243 arg2 = static_cast< wxDateTime::NameFlags >(val2);
22244 }
22245 {
22246 PyThreadState* __tstate = wxPyBeginAllowThreads();
22247 result = wxDateTime::GetWeekDayName(arg1,arg2);
22248 wxPyEndAllowThreads(__tstate);
22249 if (PyErr_Occurred()) SWIG_fail;
22250 }
22251 {
22252 #if wxUSE_UNICODE
22253 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22254 #else
22255 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22256 #endif
22257 }
22258 return resultobj;
22259 fail:
22260 return NULL;
22261 }
22262
22263
22264 SWIGINTERN PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22265 PyObject *resultobj = 0;
22266 PyObject *result = 0 ;
22267
22268 if (!SWIG_Python_UnpackTuple(args,"DateTime_GetAmPmStrings",0,0,0)) SWIG_fail;
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = (PyObject *)wxDateTime_GetAmPmStrings();
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 resultobj = result;
22276 return resultobj;
22277 fail:
22278 return NULL;
22279 }
22280
22281
22282 SWIGINTERN PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22283 PyObject *resultobj = 0;
22284 int arg1 = (int) wxDateTime::Inv_Year ;
22285 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22286 bool result;
22287 int val1 ;
22288 int ecode1 = 0 ;
22289 int val2 ;
22290 int ecode2 = 0 ;
22291 PyObject * obj0 = 0 ;
22292 PyObject * obj1 = 0 ;
22293 char * kwnames[] = {
22294 (char *) "year",(char *) "country", NULL
22295 };
22296
22297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) SWIG_fail;
22298 if (obj0) {
22299 ecode1 = SWIG_AsVal_int(obj0, &val1);
22300 if (!SWIG_IsOK(ecode1)) {
22301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "1"" of type '" "int""'");
22302 }
22303 arg1 = static_cast< int >(val1);
22304 }
22305 if (obj1) {
22306 ecode2 = SWIG_AsVal_int(obj1, &val2);
22307 if (!SWIG_IsOK(ecode2)) {
22308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDSTApplicable" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22309 }
22310 arg2 = static_cast< wxDateTime::Country >(val2);
22311 }
22312 {
22313 PyThreadState* __tstate = wxPyBeginAllowThreads();
22314 result = (bool)wxDateTime::IsDSTApplicable(arg1,arg2);
22315 wxPyEndAllowThreads(__tstate);
22316 if (PyErr_Occurred()) SWIG_fail;
22317 }
22318 {
22319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22320 }
22321 return resultobj;
22322 fail:
22323 return NULL;
22324 }
22325
22326
22327 SWIGINTERN PyObject *_wrap_DateTime_GetBeginDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22328 PyObject *resultobj = 0;
22329 int arg1 = (int) wxDateTime::Inv_Year ;
22330 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22331 wxDateTime result;
22332 int val1 ;
22333 int ecode1 = 0 ;
22334 int val2 ;
22335 int ecode2 = 0 ;
22336 PyObject * obj0 = 0 ;
22337 PyObject * obj1 = 0 ;
22338 char * kwnames[] = {
22339 (char *) "year",(char *) "country", NULL
22340 };
22341
22342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) SWIG_fail;
22343 if (obj0) {
22344 ecode1 = SWIG_AsVal_int(obj0, &val1);
22345 if (!SWIG_IsOK(ecode1)) {
22346 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetBeginDST" "', expected argument " "1"" of type '" "int""'");
22347 }
22348 arg1 = static_cast< int >(val1);
22349 }
22350 if (obj1) {
22351 ecode2 = SWIG_AsVal_int(obj1, &val2);
22352 if (!SWIG_IsOK(ecode2)) {
22353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetBeginDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22354 }
22355 arg2 = static_cast< wxDateTime::Country >(val2);
22356 }
22357 {
22358 PyThreadState* __tstate = wxPyBeginAllowThreads();
22359 result = wxDateTime::GetBeginDST(arg1,arg2);
22360 wxPyEndAllowThreads(__tstate);
22361 if (PyErr_Occurred()) SWIG_fail;
22362 }
22363 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22364 return resultobj;
22365 fail:
22366 return NULL;
22367 }
22368
22369
22370 SWIGINTERN PyObject *_wrap_DateTime_GetEndDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22371 PyObject *resultobj = 0;
22372 int arg1 = (int) wxDateTime::Inv_Year ;
22373 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22374 wxDateTime result;
22375 int val1 ;
22376 int ecode1 = 0 ;
22377 int val2 ;
22378 int ecode2 = 0 ;
22379 PyObject * obj0 = 0 ;
22380 PyObject * obj1 = 0 ;
22381 char * kwnames[] = {
22382 (char *) "year",(char *) "country", NULL
22383 };
22384
22385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) SWIG_fail;
22386 if (obj0) {
22387 ecode1 = SWIG_AsVal_int(obj0, &val1);
22388 if (!SWIG_IsOK(ecode1)) {
22389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_GetEndDST" "', expected argument " "1"" of type '" "int""'");
22390 }
22391 arg1 = static_cast< int >(val1);
22392 }
22393 if (obj1) {
22394 ecode2 = SWIG_AsVal_int(obj1, &val2);
22395 if (!SWIG_IsOK(ecode2)) {
22396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetEndDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
22397 }
22398 arg2 = static_cast< wxDateTime::Country >(val2);
22399 }
22400 {
22401 PyThreadState* __tstate = wxPyBeginAllowThreads();
22402 result = wxDateTime::GetEndDST(arg1,arg2);
22403 wxPyEndAllowThreads(__tstate);
22404 if (PyErr_Occurred()) SWIG_fail;
22405 }
22406 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22407 return resultobj;
22408 fail:
22409 return NULL;
22410 }
22411
22412
22413 SWIGINTERN PyObject *_wrap_DateTime_Now(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22414 PyObject *resultobj = 0;
22415 wxDateTime result;
22416
22417 if (!SWIG_Python_UnpackTuple(args,"DateTime_Now",0,0,0)) SWIG_fail;
22418 {
22419 PyThreadState* __tstate = wxPyBeginAllowThreads();
22420 result = wxDateTime::Now();
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 SWIGINTERN PyObject *_wrap_DateTime_UNow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22432 PyObject *resultobj = 0;
22433 wxDateTime result;
22434
22435 if (!SWIG_Python_UnpackTuple(args,"DateTime_UNow",0,0,0)) SWIG_fail;
22436 {
22437 PyThreadState* __tstate = wxPyBeginAllowThreads();
22438 result = wxDateTime::UNow();
22439 wxPyEndAllowThreads(__tstate);
22440 if (PyErr_Occurred()) SWIG_fail;
22441 }
22442 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22443 return resultobj;
22444 fail:
22445 return NULL;
22446 }
22447
22448
22449 SWIGINTERN PyObject *_wrap_DateTime_Today(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22450 PyObject *resultobj = 0;
22451 wxDateTime result;
22452
22453 if (!SWIG_Python_UnpackTuple(args,"DateTime_Today",0,0,0)) SWIG_fail;
22454 {
22455 PyThreadState* __tstate = wxPyBeginAllowThreads();
22456 result = wxDateTime::Today();
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 SWIGINTERN PyObject *_wrap_new_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22468 PyObject *resultobj = 0;
22469 wxDateTime *result = 0 ;
22470
22471 if (!SWIG_Python_UnpackTuple(args,"new_DateTime",0,0,0)) SWIG_fail;
22472 {
22473 PyThreadState* __tstate = wxPyBeginAllowThreads();
22474 result = (wxDateTime *)new wxDateTime();
22475 wxPyEndAllowThreads(__tstate);
22476 if (PyErr_Occurred()) SWIG_fail;
22477 }
22478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_NEW | 0 );
22479 return resultobj;
22480 fail:
22481 return NULL;
22482 }
22483
22484
22485 SWIGINTERN PyObject *_wrap_new_DateTimeFromTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22486 PyObject *resultobj = 0;
22487 time_t arg1 ;
22488 wxDateTime *result = 0 ;
22489 unsigned int val1 ;
22490 int ecode1 = 0 ;
22491 PyObject * obj0 = 0 ;
22492 char * kwnames[] = {
22493 (char *) "timet", NULL
22494 };
22495
22496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) SWIG_fail;
22497 ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
22498 if (!SWIG_IsOK(ecode1)) {
22499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromTimeT" "', expected argument " "1"" of type '" "time_t""'");
22500 }
22501 arg1 = static_cast< time_t >(val1);
22502 {
22503 PyThreadState* __tstate = wxPyBeginAllowThreads();
22504 result = (wxDateTime *)new wxDateTime(arg1);
22505 wxPyEndAllowThreads(__tstate);
22506 if (PyErr_Occurred()) SWIG_fail;
22507 }
22508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22509 return resultobj;
22510 fail:
22511 return NULL;
22512 }
22513
22514
22515 SWIGINTERN PyObject *_wrap_new_DateTimeFromJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22516 PyObject *resultobj = 0;
22517 double arg1 ;
22518 wxDateTime *result = 0 ;
22519 double val1 ;
22520 int ecode1 = 0 ;
22521 PyObject * obj0 = 0 ;
22522 char * kwnames[] = {
22523 (char *) "jdn", NULL
22524 };
22525
22526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) SWIG_fail;
22527 ecode1 = SWIG_AsVal_double(obj0, &val1);
22528 if (!SWIG_IsOK(ecode1)) {
22529 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromJDN" "', expected argument " "1"" of type '" "double""'");
22530 }
22531 arg1 = static_cast< double >(val1);
22532 {
22533 PyThreadState* __tstate = wxPyBeginAllowThreads();
22534 result = (wxDateTime *)new wxDateTime(arg1);
22535 wxPyEndAllowThreads(__tstate);
22536 if (PyErr_Occurred()) SWIG_fail;
22537 }
22538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22539 return resultobj;
22540 fail:
22541 return NULL;
22542 }
22543
22544
22545 SWIGINTERN PyObject *_wrap_new_DateTimeFromHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22546 PyObject *resultobj = 0;
22547 int arg1 ;
22548 int arg2 = (int) 0 ;
22549 int arg3 = (int) 0 ;
22550 int arg4 = (int) 0 ;
22551 wxDateTime *result = 0 ;
22552 int val1 ;
22553 int ecode1 = 0 ;
22554 int val2 ;
22555 int ecode2 = 0 ;
22556 int val3 ;
22557 int ecode3 = 0 ;
22558 int val4 ;
22559 int ecode4 = 0 ;
22560 PyObject * obj0 = 0 ;
22561 PyObject * obj1 = 0 ;
22562 PyObject * obj2 = 0 ;
22563 PyObject * obj3 = 0 ;
22564 char * kwnames[] = {
22565 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22566 };
22567
22568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22569 ecode1 = SWIG_AsVal_int(obj0, &val1);
22570 if (!SWIG_IsOK(ecode1)) {
22571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromHMS" "', expected argument " "1"" of type '" "int""'");
22572 }
22573 arg1 = static_cast< int >(val1);
22574 if (obj1) {
22575 ecode2 = SWIG_AsVal_int(obj1, &val2);
22576 if (!SWIG_IsOK(ecode2)) {
22577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromHMS" "', expected argument " "2"" of type '" "int""'");
22578 }
22579 arg2 = static_cast< int >(val2);
22580 }
22581 if (obj2) {
22582 ecode3 = SWIG_AsVal_int(obj2, &val3);
22583 if (!SWIG_IsOK(ecode3)) {
22584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromHMS" "', expected argument " "3"" of type '" "int""'");
22585 }
22586 arg3 = static_cast< int >(val3);
22587 }
22588 if (obj3) {
22589 ecode4 = SWIG_AsVal_int(obj3, &val4);
22590 if (!SWIG_IsOK(ecode4)) {
22591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromHMS" "', expected argument " "4"" of type '" "int""'");
22592 }
22593 arg4 = static_cast< int >(val4);
22594 }
22595 {
22596 PyThreadState* __tstate = wxPyBeginAllowThreads();
22597 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
22598 wxPyEndAllowThreads(__tstate);
22599 if (PyErr_Occurred()) SWIG_fail;
22600 }
22601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 SWIGINTERN PyObject *_wrap_new_DateTimeFromDMY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22609 PyObject *resultobj = 0;
22610 int arg1 ;
22611 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22612 int arg3 = (int) wxDateTime::Inv_Year ;
22613 int arg4 = (int) 0 ;
22614 int arg5 = (int) 0 ;
22615 int arg6 = (int) 0 ;
22616 int arg7 = (int) 0 ;
22617 wxDateTime *result = 0 ;
22618 int val1 ;
22619 int ecode1 = 0 ;
22620 int val2 ;
22621 int ecode2 = 0 ;
22622 int val3 ;
22623 int ecode3 = 0 ;
22624 int val4 ;
22625 int ecode4 = 0 ;
22626 int val5 ;
22627 int ecode5 = 0 ;
22628 int val6 ;
22629 int ecode6 = 0 ;
22630 int val7 ;
22631 int ecode7 = 0 ;
22632 PyObject * obj0 = 0 ;
22633 PyObject * obj1 = 0 ;
22634 PyObject * obj2 = 0 ;
22635 PyObject * obj3 = 0 ;
22636 PyObject * obj4 = 0 ;
22637 PyObject * obj5 = 0 ;
22638 PyObject * obj6 = 0 ;
22639 char * kwnames[] = {
22640 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22641 };
22642
22643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
22644 ecode1 = SWIG_AsVal_int(obj0, &val1);
22645 if (!SWIG_IsOK(ecode1)) {
22646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateTimeFromDMY" "', expected argument " "1"" of type '" "int""'");
22647 }
22648 arg1 = static_cast< int >(val1);
22649 if (obj1) {
22650 ecode2 = SWIG_AsVal_int(obj1, &val2);
22651 if (!SWIG_IsOK(ecode2)) {
22652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateTimeFromDMY" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
22653 }
22654 arg2 = static_cast< wxDateTime::Month >(val2);
22655 }
22656 if (obj2) {
22657 ecode3 = SWIG_AsVal_int(obj2, &val3);
22658 if (!SWIG_IsOK(ecode3)) {
22659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateTimeFromDMY" "', expected argument " "3"" of type '" "int""'");
22660 }
22661 arg3 = static_cast< int >(val3);
22662 }
22663 if (obj3) {
22664 ecode4 = SWIG_AsVal_int(obj3, &val4);
22665 if (!SWIG_IsOK(ecode4)) {
22666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateTimeFromDMY" "', expected argument " "4"" of type '" "int""'");
22667 }
22668 arg4 = static_cast< int >(val4);
22669 }
22670 if (obj4) {
22671 ecode5 = SWIG_AsVal_int(obj4, &val5);
22672 if (!SWIG_IsOK(ecode5)) {
22673 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DateTimeFromDMY" "', expected argument " "5"" of type '" "int""'");
22674 }
22675 arg5 = static_cast< int >(val5);
22676 }
22677 if (obj5) {
22678 ecode6 = SWIG_AsVal_int(obj5, &val6);
22679 if (!SWIG_IsOK(ecode6)) {
22680 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DateTimeFromDMY" "', expected argument " "6"" of type '" "int""'");
22681 }
22682 arg6 = static_cast< int >(val6);
22683 }
22684 if (obj6) {
22685 ecode7 = SWIG_AsVal_int(obj6, &val7);
22686 if (!SWIG_IsOK(ecode7)) {
22687 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_DateTimeFromDMY" "', expected argument " "7"" of type '" "int""'");
22688 }
22689 arg7 = static_cast< int >(val7);
22690 }
22691 {
22692 PyThreadState* __tstate = wxPyBeginAllowThreads();
22693 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
22694 wxPyEndAllowThreads(__tstate);
22695 if (PyErr_Occurred()) SWIG_fail;
22696 }
22697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22698 return resultobj;
22699 fail:
22700 return NULL;
22701 }
22702
22703
22704 SWIGINTERN PyObject *_wrap_new_DateTimeFromDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22705 PyObject *resultobj = 0;
22706 wxDateTime *arg1 = 0 ;
22707 wxDateTime *result = 0 ;
22708 void *argp1 = 0 ;
22709 int res1 = 0 ;
22710 PyObject * obj0 = 0 ;
22711 char * kwnames[] = {
22712 (char *) "date", NULL
22713 };
22714
22715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromDateTime",kwnames,&obj0)) SWIG_fail;
22716 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDateTime, 0 | 0);
22717 if (!SWIG_IsOK(res1)) {
22718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22719 }
22720 if (!argp1) {
22721 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateTimeFromDateTime" "', expected argument " "1"" of type '" "wxDateTime const &""'");
22722 }
22723 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22724 {
22725 PyThreadState* __tstate = wxPyBeginAllowThreads();
22726 result = (wxDateTime *)new wxDateTime((wxDateTime const &)*arg1);
22727 wxPyEndAllowThreads(__tstate);
22728 if (PyErr_Occurred()) SWIG_fail;
22729 }
22730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
22731 return resultobj;
22732 fail:
22733 return NULL;
22734 }
22735
22736
22737 SWIGINTERN PyObject *_wrap_delete_DateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22738 PyObject *resultobj = 0;
22739 wxDateTime *arg1 = (wxDateTime *) 0 ;
22740 void *argp1 = 0 ;
22741 int res1 = 0 ;
22742 PyObject *swig_obj[1] ;
22743
22744 if (!args) SWIG_fail;
22745 swig_obj[0] = args;
22746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
22747 if (!SWIG_IsOK(res1)) {
22748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
22749 }
22750 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22751 {
22752 PyThreadState* __tstate = wxPyBeginAllowThreads();
22753 delete arg1;
22754
22755 wxPyEndAllowThreads(__tstate);
22756 if (PyErr_Occurred()) SWIG_fail;
22757 }
22758 resultobj = SWIG_Py_Void();
22759 return resultobj;
22760 fail:
22761 return NULL;
22762 }
22763
22764
22765 SWIGINTERN PyObject *_wrap_DateTime_SetToCurrent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22766 PyObject *resultobj = 0;
22767 wxDateTime *arg1 = (wxDateTime *) 0 ;
22768 wxDateTime *result = 0 ;
22769 void *argp1 = 0 ;
22770 int res1 = 0 ;
22771 PyObject *swig_obj[1] ;
22772
22773 if (!args) SWIG_fail;
22774 swig_obj[0] = args;
22775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22776 if (!SWIG_IsOK(res1)) {
22777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToCurrent" "', expected argument " "1"" of type '" "wxDateTime *""'");
22778 }
22779 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22780 {
22781 PyThreadState* __tstate = wxPyBeginAllowThreads();
22782 {
22783 wxDateTime &_result_ref = (arg1)->SetToCurrent();
22784 result = (wxDateTime *) &_result_ref;
22785 }
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 SWIGINTERN PyObject *_wrap_DateTime_SetTimeT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22797 PyObject *resultobj = 0;
22798 wxDateTime *arg1 = (wxDateTime *) 0 ;
22799 time_t arg2 ;
22800 wxDateTime *result = 0 ;
22801 void *argp1 = 0 ;
22802 int res1 = 0 ;
22803 unsigned int val2 ;
22804 int ecode2 = 0 ;
22805 PyObject * obj0 = 0 ;
22806 PyObject * obj1 = 0 ;
22807 char * kwnames[] = {
22808 (char *) "self",(char *) "timet", NULL
22809 };
22810
22811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) SWIG_fail;
22812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22813 if (!SWIG_IsOK(res1)) {
22814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetTimeT" "', expected argument " "1"" of type '" "wxDateTime *""'");
22815 }
22816 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22817 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
22818 if (!SWIG_IsOK(ecode2)) {
22819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetTimeT" "', expected argument " "2"" of type '" "time_t""'");
22820 }
22821 arg2 = static_cast< time_t >(val2);
22822 {
22823 PyThreadState* __tstate = wxPyBeginAllowThreads();
22824 {
22825 wxDateTime &_result_ref = (arg1)->Set(arg2);
22826 result = (wxDateTime *) &_result_ref;
22827 }
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 SWIGINTERN PyObject *_wrap_DateTime_SetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22839 PyObject *resultobj = 0;
22840 wxDateTime *arg1 = (wxDateTime *) 0 ;
22841 double arg2 ;
22842 wxDateTime *result = 0 ;
22843 void *argp1 = 0 ;
22844 int res1 = 0 ;
22845 double val2 ;
22846 int ecode2 = 0 ;
22847 PyObject * obj0 = 0 ;
22848 PyObject * obj1 = 0 ;
22849 char * kwnames[] = {
22850 (char *) "self",(char *) "jdn", NULL
22851 };
22852
22853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) SWIG_fail;
22854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22855 if (!SWIG_IsOK(res1)) {
22856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
22857 }
22858 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22859 ecode2 = SWIG_AsVal_double(obj1, &val2);
22860 if (!SWIG_IsOK(ecode2)) {
22861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetJDN" "', expected argument " "2"" of type '" "double""'");
22862 }
22863 arg2 = static_cast< double >(val2);
22864 {
22865 PyThreadState* __tstate = wxPyBeginAllowThreads();
22866 {
22867 wxDateTime &_result_ref = (arg1)->Set(arg2);
22868 result = (wxDateTime *) &_result_ref;
22869 }
22870 wxPyEndAllowThreads(__tstate);
22871 if (PyErr_Occurred()) SWIG_fail;
22872 }
22873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22874 return resultobj;
22875 fail:
22876 return NULL;
22877 }
22878
22879
22880 SWIGINTERN PyObject *_wrap_DateTime_SetHMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22881 PyObject *resultobj = 0;
22882 wxDateTime *arg1 = (wxDateTime *) 0 ;
22883 int arg2 ;
22884 int arg3 = (int) 0 ;
22885 int arg4 = (int) 0 ;
22886 int arg5 = (int) 0 ;
22887 wxDateTime *result = 0 ;
22888 void *argp1 = 0 ;
22889 int res1 = 0 ;
22890 int val2 ;
22891 int ecode2 = 0 ;
22892 int val3 ;
22893 int ecode3 = 0 ;
22894 int val4 ;
22895 int ecode4 = 0 ;
22896 int val5 ;
22897 int ecode5 = 0 ;
22898 PyObject * obj0 = 0 ;
22899 PyObject * obj1 = 0 ;
22900 PyObject * obj2 = 0 ;
22901 PyObject * obj3 = 0 ;
22902 PyObject * obj4 = 0 ;
22903 char * kwnames[] = {
22904 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22905 };
22906
22907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
22908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22909 if (!SWIG_IsOK(res1)) {
22910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHMS" "', expected argument " "1"" of type '" "wxDateTime *""'");
22911 }
22912 arg1 = reinterpret_cast< wxDateTime * >(argp1);
22913 ecode2 = SWIG_AsVal_int(obj1, &val2);
22914 if (!SWIG_IsOK(ecode2)) {
22915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHMS" "', expected argument " "2"" of type '" "int""'");
22916 }
22917 arg2 = static_cast< int >(val2);
22918 if (obj2) {
22919 ecode3 = SWIG_AsVal_int(obj2, &val3);
22920 if (!SWIG_IsOK(ecode3)) {
22921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetHMS" "', expected argument " "3"" of type '" "int""'");
22922 }
22923 arg3 = static_cast< int >(val3);
22924 }
22925 if (obj3) {
22926 ecode4 = SWIG_AsVal_int(obj3, &val4);
22927 if (!SWIG_IsOK(ecode4)) {
22928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetHMS" "', expected argument " "4"" of type '" "int""'");
22929 }
22930 arg4 = static_cast< int >(val4);
22931 }
22932 if (obj4) {
22933 ecode5 = SWIG_AsVal_int(obj4, &val5);
22934 if (!SWIG_IsOK(ecode5)) {
22935 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetHMS" "', expected argument " "5"" of type '" "int""'");
22936 }
22937 arg5 = static_cast< int >(val5);
22938 }
22939 {
22940 PyThreadState* __tstate = wxPyBeginAllowThreads();
22941 {
22942 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
22943 result = (wxDateTime *) &_result_ref;
22944 }
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
22949 return resultobj;
22950 fail:
22951 return NULL;
22952 }
22953
22954
22955 SWIGINTERN PyObject *_wrap_DateTime_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22956 PyObject *resultobj = 0;
22957 wxDateTime *arg1 = (wxDateTime *) 0 ;
22958 int arg2 ;
22959 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
22960 int arg4 = (int) wxDateTime::Inv_Year ;
22961 int arg5 = (int) 0 ;
22962 int arg6 = (int) 0 ;
22963 int arg7 = (int) 0 ;
22964 int arg8 = (int) 0 ;
22965 wxDateTime *result = 0 ;
22966 void *argp1 = 0 ;
22967 int res1 = 0 ;
22968 int val2 ;
22969 int ecode2 = 0 ;
22970 int val3 ;
22971 int ecode3 = 0 ;
22972 int val4 ;
22973 int ecode4 = 0 ;
22974 int val5 ;
22975 int ecode5 = 0 ;
22976 int val6 ;
22977 int ecode6 = 0 ;
22978 int val7 ;
22979 int ecode7 = 0 ;
22980 int val8 ;
22981 int ecode8 = 0 ;
22982 PyObject * obj0 = 0 ;
22983 PyObject * obj1 = 0 ;
22984 PyObject * obj2 = 0 ;
22985 PyObject * obj3 = 0 ;
22986 PyObject * obj4 = 0 ;
22987 PyObject * obj5 = 0 ;
22988 PyObject * obj6 = 0 ;
22989 PyObject * obj7 = 0 ;
22990 char * kwnames[] = {
22991 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
22992 };
22993
22994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
22995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
22996 if (!SWIG_IsOK(res1)) {
22997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Set" "', expected argument " "1"" of type '" "wxDateTime *""'");
22998 }
22999 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23000 ecode2 = SWIG_AsVal_int(obj1, &val2);
23001 if (!SWIG_IsOK(ecode2)) {
23002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_Set" "', expected argument " "2"" of type '" "int""'");
23003 }
23004 arg2 = static_cast< int >(val2);
23005 if (obj2) {
23006 ecode3 = SWIG_AsVal_int(obj2, &val3);
23007 if (!SWIG_IsOK(ecode3)) {
23008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_Set" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23009 }
23010 arg3 = static_cast< wxDateTime::Month >(val3);
23011 }
23012 if (obj3) {
23013 ecode4 = SWIG_AsVal_int(obj3, &val4);
23014 if (!SWIG_IsOK(ecode4)) {
23015 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_Set" "', expected argument " "4"" of type '" "int""'");
23016 }
23017 arg4 = static_cast< int >(val4);
23018 }
23019 if (obj4) {
23020 ecode5 = SWIG_AsVal_int(obj4, &val5);
23021 if (!SWIG_IsOK(ecode5)) {
23022 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_Set" "', expected argument " "5"" of type '" "int""'");
23023 }
23024 arg5 = static_cast< int >(val5);
23025 }
23026 if (obj5) {
23027 ecode6 = SWIG_AsVal_int(obj5, &val6);
23028 if (!SWIG_IsOK(ecode6)) {
23029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DateTime_Set" "', expected argument " "6"" of type '" "int""'");
23030 }
23031 arg6 = static_cast< int >(val6);
23032 }
23033 if (obj6) {
23034 ecode7 = SWIG_AsVal_int(obj6, &val7);
23035 if (!SWIG_IsOK(ecode7)) {
23036 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DateTime_Set" "', expected argument " "7"" of type '" "int""'");
23037 }
23038 arg7 = static_cast< int >(val7);
23039 }
23040 if (obj7) {
23041 ecode8 = SWIG_AsVal_int(obj7, &val8);
23042 if (!SWIG_IsOK(ecode8)) {
23043 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "DateTime_Set" "', expected argument " "8"" of type '" "int""'");
23044 }
23045 arg8 = static_cast< int >(val8);
23046 }
23047 {
23048 PyThreadState* __tstate = wxPyBeginAllowThreads();
23049 {
23050 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
23051 result = (wxDateTime *) &_result_ref;
23052 }
23053 wxPyEndAllowThreads(__tstate);
23054 if (PyErr_Occurred()) SWIG_fail;
23055 }
23056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23057 return resultobj;
23058 fail:
23059 return NULL;
23060 }
23061
23062
23063 SWIGINTERN PyObject *_wrap_DateTime_ResetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23064 PyObject *resultobj = 0;
23065 wxDateTime *arg1 = (wxDateTime *) 0 ;
23066 wxDateTime *result = 0 ;
23067 void *argp1 = 0 ;
23068 int res1 = 0 ;
23069 PyObject *swig_obj[1] ;
23070
23071 if (!args) SWIG_fail;
23072 swig_obj[0] = args;
23073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23074 if (!SWIG_IsOK(res1)) {
23075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ResetTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
23076 }
23077 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23078 {
23079 PyThreadState* __tstate = wxPyBeginAllowThreads();
23080 {
23081 wxDateTime &_result_ref = (arg1)->ResetTime();
23082 result = (wxDateTime *) &_result_ref;
23083 }
23084 wxPyEndAllowThreads(__tstate);
23085 if (PyErr_Occurred()) SWIG_fail;
23086 }
23087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_DateTime_SetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23095 PyObject *resultobj = 0;
23096 wxDateTime *arg1 = (wxDateTime *) 0 ;
23097 int arg2 ;
23098 wxDateTime *result = 0 ;
23099 void *argp1 = 0 ;
23100 int res1 = 0 ;
23101 int val2 ;
23102 int ecode2 = 0 ;
23103 PyObject * obj0 = 0 ;
23104 PyObject * obj1 = 0 ;
23105 char * kwnames[] = {
23106 (char *) "self",(char *) "year", NULL
23107 };
23108
23109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) SWIG_fail;
23110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23111 if (!SWIG_IsOK(res1)) {
23112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetYear" "', expected argument " "1"" of type '" "wxDateTime *""'");
23113 }
23114 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23115 ecode2 = SWIG_AsVal_int(obj1, &val2);
23116 if (!SWIG_IsOK(ecode2)) {
23117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetYear" "', expected argument " "2"" of type '" "int""'");
23118 }
23119 arg2 = static_cast< int >(val2);
23120 {
23121 PyThreadState* __tstate = wxPyBeginAllowThreads();
23122 {
23123 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
23124 result = (wxDateTime *) &_result_ref;
23125 }
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *_wrap_DateTime_SetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23137 PyObject *resultobj = 0;
23138 wxDateTime *arg1 = (wxDateTime *) 0 ;
23139 wxDateTime::Month arg2 ;
23140 wxDateTime *result = 0 ;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 int val2 ;
23144 int ecode2 = 0 ;
23145 PyObject * obj0 = 0 ;
23146 PyObject * obj1 = 0 ;
23147 char * kwnames[] = {
23148 (char *) "self",(char *) "month", NULL
23149 };
23150
23151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
23152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23153 if (!SWIG_IsOK(res1)) {
23154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMonth" "', expected argument " "1"" of type '" "wxDateTime *""'");
23155 }
23156 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23157 ecode2 = SWIG_AsVal_int(obj1, &val2);
23158 if (!SWIG_IsOK(ecode2)) {
23159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMonth" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
23160 }
23161 arg2 = static_cast< wxDateTime::Month >(val2);
23162 {
23163 PyThreadState* __tstate = wxPyBeginAllowThreads();
23164 {
23165 wxDateTime &_result_ref = (arg1)->SetMonth(arg2);
23166 result = (wxDateTime *) &_result_ref;
23167 }
23168 wxPyEndAllowThreads(__tstate);
23169 if (PyErr_Occurred()) SWIG_fail;
23170 }
23171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23172 return resultobj;
23173 fail:
23174 return NULL;
23175 }
23176
23177
23178 SWIGINTERN PyObject *_wrap_DateTime_SetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj = 0;
23180 wxDateTime *arg1 = (wxDateTime *) 0 ;
23181 int arg2 ;
23182 wxDateTime *result = 0 ;
23183 void *argp1 = 0 ;
23184 int res1 = 0 ;
23185 int val2 ;
23186 int ecode2 = 0 ;
23187 PyObject * obj0 = 0 ;
23188 PyObject * obj1 = 0 ;
23189 char * kwnames[] = {
23190 (char *) "self",(char *) "day", NULL
23191 };
23192
23193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) SWIG_fail;
23194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23195 if (!SWIG_IsOK(res1)) {
23196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23197 }
23198 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23199 ecode2 = SWIG_AsVal_int(obj1, &val2);
23200 if (!SWIG_IsOK(ecode2)) {
23201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetDay" "', expected argument " "2"" of type '" "int""'");
23202 }
23203 arg2 = static_cast< int >(val2);
23204 {
23205 PyThreadState* __tstate = wxPyBeginAllowThreads();
23206 {
23207 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
23208 result = (wxDateTime *) &_result_ref;
23209 }
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 SWIGINTERN PyObject *_wrap_DateTime_SetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj = 0;
23222 wxDateTime *arg1 = (wxDateTime *) 0 ;
23223 int arg2 ;
23224 wxDateTime *result = 0 ;
23225 void *argp1 = 0 ;
23226 int res1 = 0 ;
23227 int val2 ;
23228 int ecode2 = 0 ;
23229 PyObject * obj0 = 0 ;
23230 PyObject * obj1 = 0 ;
23231 char * kwnames[] = {
23232 (char *) "self",(char *) "hour", NULL
23233 };
23234
23235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) SWIG_fail;
23236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23237 if (!SWIG_IsOK(res1)) {
23238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetHour" "', expected argument " "1"" of type '" "wxDateTime *""'");
23239 }
23240 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23241 ecode2 = SWIG_AsVal_int(obj1, &val2);
23242 if (!SWIG_IsOK(ecode2)) {
23243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetHour" "', expected argument " "2"" of type '" "int""'");
23244 }
23245 arg2 = static_cast< int >(val2);
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 {
23249 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
23250 result = (wxDateTime *) &_result_ref;
23251 }
23252 wxPyEndAllowThreads(__tstate);
23253 if (PyErr_Occurred()) SWIG_fail;
23254 }
23255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23256 return resultobj;
23257 fail:
23258 return NULL;
23259 }
23260
23261
23262 SWIGINTERN PyObject *_wrap_DateTime_SetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23263 PyObject *resultobj = 0;
23264 wxDateTime *arg1 = (wxDateTime *) 0 ;
23265 int arg2 ;
23266 wxDateTime *result = 0 ;
23267 void *argp1 = 0 ;
23268 int res1 = 0 ;
23269 int val2 ;
23270 int ecode2 = 0 ;
23271 PyObject * obj0 = 0 ;
23272 PyObject * obj1 = 0 ;
23273 char * kwnames[] = {
23274 (char *) "self",(char *) "minute", NULL
23275 };
23276
23277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
23278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23279 if (!SWIG_IsOK(res1)) {
23280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMinute" "', expected argument " "1"" of type '" "wxDateTime *""'");
23281 }
23282 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23283 ecode2 = SWIG_AsVal_int(obj1, &val2);
23284 if (!SWIG_IsOK(ecode2)) {
23285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMinute" "', expected argument " "2"" of type '" "int""'");
23286 }
23287 arg2 = static_cast< int >(val2);
23288 {
23289 PyThreadState* __tstate = wxPyBeginAllowThreads();
23290 {
23291 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
23292 result = (wxDateTime *) &_result_ref;
23293 }
23294 wxPyEndAllowThreads(__tstate);
23295 if (PyErr_Occurred()) SWIG_fail;
23296 }
23297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23298 return resultobj;
23299 fail:
23300 return NULL;
23301 }
23302
23303
23304 SWIGINTERN PyObject *_wrap_DateTime_SetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23305 PyObject *resultobj = 0;
23306 wxDateTime *arg1 = (wxDateTime *) 0 ;
23307 int arg2 ;
23308 wxDateTime *result = 0 ;
23309 void *argp1 = 0 ;
23310 int res1 = 0 ;
23311 int val2 ;
23312 int ecode2 = 0 ;
23313 PyObject * obj0 = 0 ;
23314 PyObject * obj1 = 0 ;
23315 char * kwnames[] = {
23316 (char *) "self",(char *) "second", NULL
23317 };
23318
23319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
23320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23321 if (!SWIG_IsOK(res1)) {
23322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetSecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23323 }
23324 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23325 ecode2 = SWIG_AsVal_int(obj1, &val2);
23326 if (!SWIG_IsOK(ecode2)) {
23327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetSecond" "', expected argument " "2"" of type '" "int""'");
23328 }
23329 arg2 = static_cast< int >(val2);
23330 {
23331 PyThreadState* __tstate = wxPyBeginAllowThreads();
23332 {
23333 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
23334 result = (wxDateTime *) &_result_ref;
23335 }
23336 wxPyEndAllowThreads(__tstate);
23337 if (PyErr_Occurred()) SWIG_fail;
23338 }
23339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23340 return resultobj;
23341 fail:
23342 return NULL;
23343 }
23344
23345
23346 SWIGINTERN PyObject *_wrap_DateTime_SetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23347 PyObject *resultobj = 0;
23348 wxDateTime *arg1 = (wxDateTime *) 0 ;
23349 int arg2 ;
23350 wxDateTime *result = 0 ;
23351 void *argp1 = 0 ;
23352 int res1 = 0 ;
23353 int val2 ;
23354 int ecode2 = 0 ;
23355 PyObject * obj0 = 0 ;
23356 PyObject * obj1 = 0 ;
23357 char * kwnames[] = {
23358 (char *) "self",(char *) "millisecond", NULL
23359 };
23360
23361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
23362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23363 if (!SWIG_IsOK(res1)) {
23364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetMillisecond" "', expected argument " "1"" of type '" "wxDateTime *""'");
23365 }
23366 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23367 ecode2 = SWIG_AsVal_int(obj1, &val2);
23368 if (!SWIG_IsOK(ecode2)) {
23369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetMillisecond" "', expected argument " "2"" of type '" "int""'");
23370 }
23371 arg2 = static_cast< int >(val2);
23372 {
23373 PyThreadState* __tstate = wxPyBeginAllowThreads();
23374 {
23375 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
23376 result = (wxDateTime *) &_result_ref;
23377 }
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23382 return resultobj;
23383 fail:
23384 return NULL;
23385 }
23386
23387
23388 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23389 PyObject *resultobj = 0;
23390 wxDateTime *arg1 = (wxDateTime *) 0 ;
23391 wxDateTime::WeekDay arg2 ;
23392 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23393 wxDateTime *result = 0 ;
23394 void *argp1 = 0 ;
23395 int res1 = 0 ;
23396 int val2 ;
23397 int ecode2 = 0 ;
23398 int val3 ;
23399 int ecode3 = 0 ;
23400 PyObject * obj0 = 0 ;
23401 PyObject * obj1 = 0 ;
23402 PyObject * obj2 = 0 ;
23403 char * kwnames[] = {
23404 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23405 };
23406
23407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23409 if (!SWIG_IsOK(res1)) {
23410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23411 }
23412 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23413 ecode2 = SWIG_AsVal_int(obj1, &val2);
23414 if (!SWIG_IsOK(ecode2)) {
23415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23416 }
23417 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23418 if (obj2) {
23419 ecode3 = SWIG_AsVal_int(obj2, &val3);
23420 if (!SWIG_IsOK(ecode3)) {
23421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23422 }
23423 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23424 }
23425 {
23426 PyThreadState* __tstate = wxPyBeginAllowThreads();
23427 {
23428 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek(arg2,arg3);
23429 result = (wxDateTime *) &_result_ref;
23430 }
23431 wxPyEndAllowThreads(__tstate);
23432 if (PyErr_Occurred()) SWIG_fail;
23433 }
23434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23442 PyObject *resultobj = 0;
23443 wxDateTime *arg1 = (wxDateTime *) 0 ;
23444 wxDateTime::WeekDay arg2 ;
23445 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23446 wxDateTime result;
23447 void *argp1 = 0 ;
23448 int res1 = 0 ;
23449 int val2 ;
23450 int ecode2 = 0 ;
23451 int val3 ;
23452 int ecode3 = 0 ;
23453 PyObject * obj0 = 0 ;
23454 PyObject * obj1 = 0 ;
23455 PyObject * obj2 = 0 ;
23456 char * kwnames[] = {
23457 (char *) "self",(char *) "weekday",(char *) "flags", NULL
23458 };
23459
23460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23462 if (!SWIG_IsOK(res1)) {
23463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23464 }
23465 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23466 ecode2 = SWIG_AsVal_int(obj1, &val2);
23467 if (!SWIG_IsOK(ecode2)) {
23468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23469 }
23470 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23471 if (obj2) {
23472 ecode3 = SWIG_AsVal_int(obj2, &val3);
23473 if (!SWIG_IsOK(ecode3)) {
23474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeekDayInSameWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekFlags""'");
23475 }
23476 arg3 = static_cast< wxDateTime::WeekFlags >(val3);
23477 }
23478 {
23479 PyThreadState* __tstate = wxPyBeginAllowThreads();
23480 result = (arg1)->GetWeekDayInSameWeek(arg2,arg3);
23481 wxPyEndAllowThreads(__tstate);
23482 if (PyErr_Occurred()) SWIG_fail;
23483 }
23484 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23485 return resultobj;
23486 fail:
23487 return NULL;
23488 }
23489
23490
23491 SWIGINTERN PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23492 PyObject *resultobj = 0;
23493 wxDateTime *arg1 = (wxDateTime *) 0 ;
23494 wxDateTime::WeekDay arg2 ;
23495 wxDateTime *result = 0 ;
23496 void *argp1 = 0 ;
23497 int res1 = 0 ;
23498 int val2 ;
23499 int ecode2 = 0 ;
23500 PyObject * obj0 = 0 ;
23501 PyObject * obj1 = 0 ;
23502 char * kwnames[] = {
23503 (char *) "self",(char *) "weekday", NULL
23504 };
23505
23506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23508 if (!SWIG_IsOK(res1)) {
23509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23510 }
23511 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23512 ecode2 = SWIG_AsVal_int(obj1, &val2);
23513 if (!SWIG_IsOK(ecode2)) {
23514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23515 }
23516 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23517 {
23518 PyThreadState* __tstate = wxPyBeginAllowThreads();
23519 {
23520 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay(arg2);
23521 result = (wxDateTime *) &_result_ref;
23522 }
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23527 return resultobj;
23528 fail:
23529 return NULL;
23530 }
23531
23532
23533 SWIGINTERN PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23534 PyObject *resultobj = 0;
23535 wxDateTime *arg1 = (wxDateTime *) 0 ;
23536 wxDateTime::WeekDay arg2 ;
23537 wxDateTime result;
23538 void *argp1 = 0 ;
23539 int res1 = 0 ;
23540 int val2 ;
23541 int ecode2 = 0 ;
23542 PyObject * obj0 = 0 ;
23543 PyObject * obj1 = 0 ;
23544 char * kwnames[] = {
23545 (char *) "self",(char *) "weekday", NULL
23546 };
23547
23548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23550 if (!SWIG_IsOK(res1)) {
23551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23552 }
23553 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23554 ecode2 = SWIG_AsVal_int(obj1, &val2);
23555 if (!SWIG_IsOK(ecode2)) {
23556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetNextWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23557 }
23558 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23559 {
23560 PyThreadState* __tstate = wxPyBeginAllowThreads();
23561 result = (arg1)->GetNextWeekDay(arg2);
23562 wxPyEndAllowThreads(__tstate);
23563 if (PyErr_Occurred()) SWIG_fail;
23564 }
23565 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23566 return resultobj;
23567 fail:
23568 return NULL;
23569 }
23570
23571
23572 SWIGINTERN PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23573 PyObject *resultobj = 0;
23574 wxDateTime *arg1 = (wxDateTime *) 0 ;
23575 wxDateTime::WeekDay arg2 ;
23576 wxDateTime *result = 0 ;
23577 void *argp1 = 0 ;
23578 int res1 = 0 ;
23579 int val2 ;
23580 int ecode2 = 0 ;
23581 PyObject * obj0 = 0 ;
23582 PyObject * obj1 = 0 ;
23583 char * kwnames[] = {
23584 (char *) "self",(char *) "weekday", NULL
23585 };
23586
23587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23589 if (!SWIG_IsOK(res1)) {
23590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23591 }
23592 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23593 ecode2 = SWIG_AsVal_int(obj1, &val2);
23594 if (!SWIG_IsOK(ecode2)) {
23595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23596 }
23597 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23598 {
23599 PyThreadState* __tstate = wxPyBeginAllowThreads();
23600 {
23601 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay(arg2);
23602 result = (wxDateTime *) &_result_ref;
23603 }
23604 wxPyEndAllowThreads(__tstate);
23605 if (PyErr_Occurred()) SWIG_fail;
23606 }
23607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
23608 return resultobj;
23609 fail:
23610 return NULL;
23611 }
23612
23613
23614 SWIGINTERN PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23615 PyObject *resultobj = 0;
23616 wxDateTime *arg1 = (wxDateTime *) 0 ;
23617 wxDateTime::WeekDay arg2 ;
23618 wxDateTime result;
23619 void *argp1 = 0 ;
23620 int res1 = 0 ;
23621 int val2 ;
23622 int ecode2 = 0 ;
23623 PyObject * obj0 = 0 ;
23624 PyObject * obj1 = 0 ;
23625 char * kwnames[] = {
23626 (char *) "self",(char *) "weekday", NULL
23627 };
23628
23629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
23630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23631 if (!SWIG_IsOK(res1)) {
23632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23633 }
23634 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23635 ecode2 = SWIG_AsVal_int(obj1, &val2);
23636 if (!SWIG_IsOK(ecode2)) {
23637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetPrevWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23638 }
23639 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23640 {
23641 PyThreadState* __tstate = wxPyBeginAllowThreads();
23642 result = (arg1)->GetPrevWeekDay(arg2);
23643 wxPyEndAllowThreads(__tstate);
23644 if (PyErr_Occurred()) SWIG_fail;
23645 }
23646 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23647 return resultobj;
23648 fail:
23649 return NULL;
23650 }
23651
23652
23653 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23654 PyObject *resultobj = 0;
23655 wxDateTime *arg1 = (wxDateTime *) 0 ;
23656 wxDateTime::WeekDay arg2 ;
23657 int arg3 = (int) 1 ;
23658 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23659 int arg5 = (int) wxDateTime::Inv_Year ;
23660 bool result;
23661 void *argp1 = 0 ;
23662 int res1 = 0 ;
23663 int val2 ;
23664 int ecode2 = 0 ;
23665 int val3 ;
23666 int ecode3 = 0 ;
23667 int val4 ;
23668 int ecode4 = 0 ;
23669 int val5 ;
23670 int ecode5 = 0 ;
23671 PyObject * obj0 = 0 ;
23672 PyObject * obj1 = 0 ;
23673 PyObject * obj2 = 0 ;
23674 PyObject * obj3 = 0 ;
23675 PyObject * obj4 = 0 ;
23676 char * kwnames[] = {
23677 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
23678 };
23679
23680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
23681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23682 if (!SWIG_IsOK(res1)) {
23683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23684 }
23685 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23686 ecode2 = SWIG_AsVal_int(obj1, &val2);
23687 if (!SWIG_IsOK(ecode2)) {
23688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23689 }
23690 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23691 if (obj2) {
23692 ecode3 = SWIG_AsVal_int(obj2, &val3);
23693 if (!SWIG_IsOK(ecode3)) {
23694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekDay" "', expected argument " "3"" of type '" "int""'");
23695 }
23696 arg3 = static_cast< int >(val3);
23697 }
23698 if (obj3) {
23699 ecode4 = SWIG_AsVal_int(obj3, &val4);
23700 if (!SWIG_IsOK(ecode4)) {
23701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToWeekDay" "', expected argument " "4"" of type '" "wxDateTime::Month""'");
23702 }
23703 arg4 = static_cast< wxDateTime::Month >(val4);
23704 }
23705 if (obj4) {
23706 ecode5 = SWIG_AsVal_int(obj4, &val5);
23707 if (!SWIG_IsOK(ecode5)) {
23708 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DateTime_SetToWeekDay" "', expected argument " "5"" of type '" "int""'");
23709 }
23710 arg5 = static_cast< int >(val5);
23711 }
23712 {
23713 PyThreadState* __tstate = wxPyBeginAllowThreads();
23714 result = (bool)(arg1)->SetToWeekDay(arg2,arg3,arg4,arg5);
23715 wxPyEndAllowThreads(__tstate);
23716 if (PyErr_Occurred()) SWIG_fail;
23717 }
23718 {
23719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23720 }
23721 return resultobj;
23722 fail:
23723 return NULL;
23724 }
23725
23726
23727 SWIGINTERN PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj = 0;
23729 wxDateTime *arg1 = (wxDateTime *) 0 ;
23730 wxDateTime::WeekDay arg2 ;
23731 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23732 int arg4 = (int) wxDateTime::Inv_Year ;
23733 bool result;
23734 void *argp1 = 0 ;
23735 int res1 = 0 ;
23736 int val2 ;
23737 int ecode2 = 0 ;
23738 int val3 ;
23739 int ecode3 = 0 ;
23740 int val4 ;
23741 int ecode4 = 0 ;
23742 PyObject * obj0 = 0 ;
23743 PyObject * obj1 = 0 ;
23744 PyObject * obj2 = 0 ;
23745 PyObject * obj3 = 0 ;
23746 char * kwnames[] = {
23747 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23748 };
23749
23750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23752 if (!SWIG_IsOK(res1)) {
23753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23754 }
23755 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23756 ecode2 = SWIG_AsVal_int(obj1, &val2);
23757 if (!SWIG_IsOK(ecode2)) {
23758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23759 }
23760 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23761 if (obj2) {
23762 ecode3 = SWIG_AsVal_int(obj2, &val3);
23763 if (!SWIG_IsOK(ecode3)) {
23764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23765 }
23766 arg3 = static_cast< wxDateTime::Month >(val3);
23767 }
23768 if (obj3) {
23769 ecode4 = SWIG_AsVal_int(obj3, &val4);
23770 if (!SWIG_IsOK(ecode4)) {
23771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23772 }
23773 arg4 = static_cast< int >(val4);
23774 }
23775 {
23776 PyThreadState* __tstate = wxPyBeginAllowThreads();
23777 result = (bool)(arg1)->SetToLastWeekDay(arg2,arg3,arg4);
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 {
23782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23783 }
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 SWIGINTERN PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23791 PyObject *resultobj = 0;
23792 wxDateTime *arg1 = (wxDateTime *) 0 ;
23793 wxDateTime::WeekDay arg2 ;
23794 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
23795 int arg4 = (int) wxDateTime::Inv_Year ;
23796 wxDateTime result;
23797 void *argp1 = 0 ;
23798 int res1 = 0 ;
23799 int val2 ;
23800 int ecode2 = 0 ;
23801 int val3 ;
23802 int ecode3 = 0 ;
23803 int val4 ;
23804 int ecode4 = 0 ;
23805 PyObject * obj0 = 0 ;
23806 PyObject * obj1 = 0 ;
23807 PyObject * obj2 = 0 ;
23808 PyObject * obj3 = 0 ;
23809 char * kwnames[] = {
23810 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
23811 };
23812
23813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23815 if (!SWIG_IsOK(res1)) {
23816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
23817 }
23818 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23819 ecode2 = SWIG_AsVal_int(obj1, &val2);
23820 if (!SWIG_IsOK(ecode2)) {
23821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "2"" of type '" "wxDateTime::WeekDay""'");
23822 }
23823 arg2 = static_cast< wxDateTime::WeekDay >(val2);
23824 if (obj2) {
23825 ecode3 = SWIG_AsVal_int(obj2, &val3);
23826 if (!SWIG_IsOK(ecode3)) {
23827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "3"" of type '" "wxDateTime::Month""'");
23828 }
23829 arg3 = static_cast< wxDateTime::Month >(val3);
23830 }
23831 if (obj3) {
23832 ecode4 = SWIG_AsVal_int(obj3, &val4);
23833 if (!SWIG_IsOK(ecode4)) {
23834 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetLastWeekDay" "', expected argument " "4"" of type '" "int""'");
23835 }
23836 arg4 = static_cast< int >(val4);
23837 }
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = (arg1)->GetLastWeekDay(arg2,arg3,arg4);
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 SWIGINTERN PyObject *_wrap_DateTime_SetToTheWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23852 PyObject *resultobj = 0;
23853 wxDateTime *arg1 = (wxDateTime *) 0 ;
23854 int arg2 ;
23855 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23856 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23857 bool result;
23858 void *argp1 = 0 ;
23859 int res1 = 0 ;
23860 int val2 ;
23861 int ecode2 = 0 ;
23862 int val3 ;
23863 int ecode3 = 0 ;
23864 int val4 ;
23865 int ecode4 = 0 ;
23866 PyObject * obj0 = 0 ;
23867 PyObject * obj1 = 0 ;
23868 PyObject * obj2 = 0 ;
23869 PyObject * obj3 = 0 ;
23870 char * kwnames[] = {
23871 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23872 };
23873
23874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23876 if (!SWIG_IsOK(res1)) {
23877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToTheWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23878 }
23879 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23880 ecode2 = SWIG_AsVal_int(obj1, &val2);
23881 if (!SWIG_IsOK(ecode2)) {
23882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToTheWeek" "', expected argument " "2"" of type '" "int""'");
23883 }
23884 arg2 = static_cast< int >(val2);
23885 if (obj2) {
23886 ecode3 = SWIG_AsVal_int(obj2, &val3);
23887 if (!SWIG_IsOK(ecode3)) {
23888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToTheWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23889 }
23890 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23891 }
23892 if (obj3) {
23893 ecode4 = SWIG_AsVal_int(obj3, &val4);
23894 if (!SWIG_IsOK(ecode4)) {
23895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_SetToTheWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23896 }
23897 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23898 }
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 result = (bool)(arg1)->SetToTheWeek(arg2,arg3,arg4);
23902 wxPyEndAllowThreads(__tstate);
23903 if (PyErr_Occurred()) SWIG_fail;
23904 }
23905 {
23906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23907 }
23908 return resultobj;
23909 fail:
23910 return NULL;
23911 }
23912
23913
23914 SWIGINTERN PyObject *_wrap_DateTime_GetWeek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23915 PyObject *resultobj = 0;
23916 wxDateTime *arg1 = (wxDateTime *) 0 ;
23917 int arg2 ;
23918 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23919 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
23920 wxDateTime result;
23921 void *argp1 = 0 ;
23922 int res1 = 0 ;
23923 int val2 ;
23924 int ecode2 = 0 ;
23925 int val3 ;
23926 int ecode3 = 0 ;
23927 int val4 ;
23928 int ecode4 = 0 ;
23929 PyObject * obj0 = 0 ;
23930 PyObject * obj1 = 0 ;
23931 PyObject * obj2 = 0 ;
23932 PyObject * obj3 = 0 ;
23933 char * kwnames[] = {
23934 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
23935 };
23936
23937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
23939 if (!SWIG_IsOK(res1)) {
23940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeek" "', expected argument " "1"" of type '" "wxDateTime *""'");
23941 }
23942 arg1 = reinterpret_cast< wxDateTime * >(argp1);
23943 ecode2 = SWIG_AsVal_int(obj1, &val2);
23944 if (!SWIG_IsOK(ecode2)) {
23945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeek" "', expected argument " "2"" of type '" "int""'");
23946 }
23947 arg2 = static_cast< int >(val2);
23948 if (obj2) {
23949 ecode3 = SWIG_AsVal_int(obj2, &val3);
23950 if (!SWIG_IsOK(ecode3)) {
23951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetWeek" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
23952 }
23953 arg3 = static_cast< wxDateTime::WeekDay >(val3);
23954 }
23955 if (obj3) {
23956 ecode4 = SWIG_AsVal_int(obj3, &val4);
23957 if (!SWIG_IsOK(ecode4)) {
23958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DateTime_GetWeek" "', expected argument " "4"" of type '" "wxDateTime::WeekFlags""'");
23959 }
23960 arg4 = static_cast< wxDateTime::WeekFlags >(val4);
23961 }
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (arg1)->GetWeek(arg2,arg3,arg4);
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23976 PyObject *resultobj = 0;
23977 int arg1 ;
23978 int arg2 ;
23979 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
23980 wxDateTime result;
23981 int val1 ;
23982 int ecode1 = 0 ;
23983 int val2 ;
23984 int ecode2 = 0 ;
23985 int val3 ;
23986 int ecode3 = 0 ;
23987 PyObject * obj0 = 0 ;
23988 PyObject * obj1 = 0 ;
23989 PyObject * obj2 = 0 ;
23990 char * kwnames[] = {
23991 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
23992 };
23993
23994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23995 ecode1 = SWIG_AsVal_int(obj0, &val1);
23996 if (!SWIG_IsOK(ecode1)) {
23997 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "1"" of type '" "int""'");
23998 }
23999 arg1 = static_cast< int >(val1);
24000 ecode2 = SWIG_AsVal_int(obj1, &val2);
24001 if (!SWIG_IsOK(ecode2)) {
24002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "2"" of type '" "int""'");
24003 }
24004 arg2 = static_cast< int >(val2);
24005 if (obj2) {
24006 ecode3 = SWIG_AsVal_int(obj2, &val3);
24007 if (!SWIG_IsOK(ecode3)) {
24008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToWeekOfYear" "', expected argument " "3"" of type '" "wxDateTime::WeekDay""'");
24009 }
24010 arg3 = static_cast< wxDateTime::WeekDay >(val3);
24011 }
24012 {
24013 PyThreadState* __tstate = wxPyBeginAllowThreads();
24014 result = wxDateTime::SetToWeekOfYear(arg1,arg2,arg3);
24015 wxPyEndAllowThreads(__tstate);
24016 if (PyErr_Occurred()) SWIG_fail;
24017 }
24018 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24019 return resultobj;
24020 fail:
24021 return NULL;
24022 }
24023
24024
24025 SWIGINTERN PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24026 PyObject *resultobj = 0;
24027 wxDateTime *arg1 = (wxDateTime *) 0 ;
24028 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24029 int arg3 = (int) wxDateTime::Inv_Year ;
24030 wxDateTime *result = 0 ;
24031 void *argp1 = 0 ;
24032 int res1 = 0 ;
24033 int val2 ;
24034 int ecode2 = 0 ;
24035 int val3 ;
24036 int ecode3 = 0 ;
24037 PyObject * obj0 = 0 ;
24038 PyObject * obj1 = 0 ;
24039 PyObject * obj2 = 0 ;
24040 char * kwnames[] = {
24041 (char *) "self",(char *) "month",(char *) "year", NULL
24042 };
24043
24044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24046 if (!SWIG_IsOK(res1)) {
24047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24048 }
24049 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24050 if (obj1) {
24051 ecode2 = SWIG_AsVal_int(obj1, &val2);
24052 if (!SWIG_IsOK(ecode2)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24054 }
24055 arg2 = static_cast< wxDateTime::Month >(val2);
24056 }
24057 if (obj2) {
24058 ecode3 = SWIG_AsVal_int(obj2, &val3);
24059 if (!SWIG_IsOK(ecode3)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_SetToLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24061 }
24062 arg3 = static_cast< int >(val3);
24063 }
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 {
24067 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay(arg2,arg3);
24068 result = (wxDateTime *) &_result_ref;
24069 }
24070 wxPyEndAllowThreads(__tstate);
24071 if (PyErr_Occurred()) SWIG_fail;
24072 }
24073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24074 return resultobj;
24075 fail:
24076 return NULL;
24077 }
24078
24079
24080 SWIGINTERN PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24081 PyObject *resultobj = 0;
24082 wxDateTime *arg1 = (wxDateTime *) 0 ;
24083 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
24084 int arg3 = (int) wxDateTime::Inv_Year ;
24085 wxDateTime result;
24086 void *argp1 = 0 ;
24087 int res1 = 0 ;
24088 int val2 ;
24089 int ecode2 = 0 ;
24090 int val3 ;
24091 int ecode3 = 0 ;
24092 PyObject * obj0 = 0 ;
24093 PyObject * obj1 = 0 ;
24094 PyObject * obj2 = 0 ;
24095 char * kwnames[] = {
24096 (char *) "self",(char *) "month",(char *) "year", NULL
24097 };
24098
24099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24101 if (!SWIG_IsOK(res1)) {
24102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24103 }
24104 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24105 if (obj1) {
24106 ecode2 = SWIG_AsVal_int(obj1, &val2);
24107 if (!SWIG_IsOK(ecode2)) {
24108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "2"" of type '" "wxDateTime::Month""'");
24109 }
24110 arg2 = static_cast< wxDateTime::Month >(val2);
24111 }
24112 if (obj2) {
24113 ecode3 = SWIG_AsVal_int(obj2, &val3);
24114 if (!SWIG_IsOK(ecode3)) {
24115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_GetLastMonthDay" "', expected argument " "3"" of type '" "int""'");
24116 }
24117 arg3 = static_cast< int >(val3);
24118 }
24119 {
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 result = (arg1)->GetLastMonthDay(arg2,arg3);
24122 wxPyEndAllowThreads(__tstate);
24123 if (PyErr_Occurred()) SWIG_fail;
24124 }
24125 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24126 return resultobj;
24127 fail:
24128 return NULL;
24129 }
24130
24131
24132 SWIGINTERN PyObject *_wrap_DateTime_SetToYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24133 PyObject *resultobj = 0;
24134 wxDateTime *arg1 = (wxDateTime *) 0 ;
24135 int arg2 ;
24136 wxDateTime *result = 0 ;
24137 void *argp1 = 0 ;
24138 int res1 = 0 ;
24139 int val2 ;
24140 int ecode2 = 0 ;
24141 PyObject * obj0 = 0 ;
24142 PyObject * obj1 = 0 ;
24143 char * kwnames[] = {
24144 (char *) "self",(char *) "yday", NULL
24145 };
24146
24147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24149 if (!SWIG_IsOK(res1)) {
24150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SetToYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24151 }
24152 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24153 ecode2 = SWIG_AsVal_int(obj1, &val2);
24154 if (!SWIG_IsOK(ecode2)) {
24155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_SetToYearDay" "', expected argument " "2"" of type '" "int""'");
24156 }
24157 arg2 = static_cast< int >(val2);
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 {
24161 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
24162 result = (wxDateTime *) &_result_ref;
24163 }
24164 wxPyEndAllowThreads(__tstate);
24165 if (PyErr_Occurred()) SWIG_fail;
24166 }
24167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24168 return resultobj;
24169 fail:
24170 return NULL;
24171 }
24172
24173
24174 SWIGINTERN PyObject *_wrap_DateTime_GetYearDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24175 PyObject *resultobj = 0;
24176 wxDateTime *arg1 = (wxDateTime *) 0 ;
24177 int arg2 ;
24178 wxDateTime result;
24179 void *argp1 = 0 ;
24180 int res1 = 0 ;
24181 int val2 ;
24182 int ecode2 = 0 ;
24183 PyObject * obj0 = 0 ;
24184 PyObject * obj1 = 0 ;
24185 char * kwnames[] = {
24186 (char *) "self",(char *) "yday", NULL
24187 };
24188
24189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) SWIG_fail;
24190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24191 if (!SWIG_IsOK(res1)) {
24192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYearDay" "', expected argument " "1"" of type '" "wxDateTime *""'");
24193 }
24194 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24195 ecode2 = SWIG_AsVal_int(obj1, &val2);
24196 if (!SWIG_IsOK(ecode2)) {
24197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetYearDay" "', expected argument " "2"" of type '" "int""'");
24198 }
24199 arg2 = static_cast< int >(val2);
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = (arg1)->GetYearDay(arg2);
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 PyObject *resultobj = 0;
24215 wxDateTime *arg1 = (wxDateTime *) 0 ;
24216 double result;
24217 void *argp1 = 0 ;
24218 int res1 = 0 ;
24219 PyObject *swig_obj[1] ;
24220
24221 if (!args) SWIG_fail;
24222 swig_obj[0] = args;
24223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24224 if (!SWIG_IsOK(res1)) {
24225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime *""'");
24226 }
24227 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24228 {
24229 PyThreadState* __tstate = wxPyBeginAllowThreads();
24230 result = (double)(arg1)->GetJulianDayNumber();
24231 wxPyEndAllowThreads(__tstate);
24232 if (PyErr_Occurred()) SWIG_fail;
24233 }
24234 resultobj = SWIG_From_double(static_cast< double >(result));
24235 return resultobj;
24236 fail:
24237 return NULL;
24238 }
24239
24240
24241 SWIGINTERN PyObject *_wrap_DateTime_GetJDN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24242 PyObject *resultobj = 0;
24243 wxDateTime *arg1 = (wxDateTime *) 0 ;
24244 double result;
24245 void *argp1 = 0 ;
24246 int res1 = 0 ;
24247 PyObject *swig_obj[1] ;
24248
24249 if (!args) SWIG_fail;
24250 swig_obj[0] = args;
24251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24252 if (!SWIG_IsOK(res1)) {
24253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetJDN" "', expected argument " "1"" of type '" "wxDateTime *""'");
24254 }
24255 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24256 {
24257 PyThreadState* __tstate = wxPyBeginAllowThreads();
24258 result = (double)(arg1)->GetJDN();
24259 wxPyEndAllowThreads(__tstate);
24260 if (PyErr_Occurred()) SWIG_fail;
24261 }
24262 resultobj = SWIG_From_double(static_cast< double >(result));
24263 return resultobj;
24264 fail:
24265 return NULL;
24266 }
24267
24268
24269 SWIGINTERN PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24270 PyObject *resultobj = 0;
24271 wxDateTime *arg1 = (wxDateTime *) 0 ;
24272 double result;
24273 void *argp1 = 0 ;
24274 int res1 = 0 ;
24275 PyObject *swig_obj[1] ;
24276
24277 if (!args) SWIG_fail;
24278 swig_obj[0] = args;
24279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24280 if (!SWIG_IsOK(res1)) {
24281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetModifiedJulianDayNumber" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24282 }
24283 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24284 {
24285 PyThreadState* __tstate = wxPyBeginAllowThreads();
24286 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
24287 wxPyEndAllowThreads(__tstate);
24288 if (PyErr_Occurred()) SWIG_fail;
24289 }
24290 resultobj = SWIG_From_double(static_cast< double >(result));
24291 return resultobj;
24292 fail:
24293 return NULL;
24294 }
24295
24296
24297 SWIGINTERN PyObject *_wrap_DateTime_GetMJD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24298 PyObject *resultobj = 0;
24299 wxDateTime *arg1 = (wxDateTime *) 0 ;
24300 double result;
24301 void *argp1 = 0 ;
24302 int res1 = 0 ;
24303 PyObject *swig_obj[1] ;
24304
24305 if (!args) SWIG_fail;
24306 swig_obj[0] = args;
24307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24308 if (!SWIG_IsOK(res1)) {
24309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMJD" "', expected argument " "1"" of type '" "wxDateTime *""'");
24310 }
24311 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24312 {
24313 PyThreadState* __tstate = wxPyBeginAllowThreads();
24314 result = (double)(arg1)->GetMJD();
24315 wxPyEndAllowThreads(__tstate);
24316 if (PyErr_Occurred()) SWIG_fail;
24317 }
24318 resultobj = SWIG_From_double(static_cast< double >(result));
24319 return resultobj;
24320 fail:
24321 return NULL;
24322 }
24323
24324
24325 SWIGINTERN PyObject *_wrap_DateTime_GetRataDie(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24326 PyObject *resultobj = 0;
24327 wxDateTime *arg1 = (wxDateTime *) 0 ;
24328 double result;
24329 void *argp1 = 0 ;
24330 int res1 = 0 ;
24331 PyObject *swig_obj[1] ;
24332
24333 if (!args) SWIG_fail;
24334 swig_obj[0] = args;
24335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24336 if (!SWIG_IsOK(res1)) {
24337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetRataDie" "', expected argument " "1"" of type '" "wxDateTime *""'");
24338 }
24339 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24340 {
24341 PyThreadState* __tstate = wxPyBeginAllowThreads();
24342 result = (double)(arg1)->GetRataDie();
24343 wxPyEndAllowThreads(__tstate);
24344 if (PyErr_Occurred()) SWIG_fail;
24345 }
24346 resultobj = SWIG_From_double(static_cast< double >(result));
24347 return resultobj;
24348 fail:
24349 return NULL;
24350 }
24351
24352
24353 SWIGINTERN PyObject *_wrap_DateTime_ToTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24354 PyObject *resultobj = 0;
24355 wxDateTime *arg1 = (wxDateTime *) 0 ;
24356 wxDateTime::TimeZone *arg2 = 0 ;
24357 bool arg3 = (bool) false ;
24358 wxDateTime result;
24359 void *argp1 = 0 ;
24360 int res1 = 0 ;
24361 bool temp2 = false ;
24362 bool val3 ;
24363 int ecode3 = 0 ;
24364 PyObject * obj0 = 0 ;
24365 PyObject * obj1 = 0 ;
24366 PyObject * obj2 = 0 ;
24367 char * kwnames[] = {
24368 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24369 };
24370
24371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24373 if (!SWIG_IsOK(res1)) {
24374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24375 }
24376 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24377 {
24378 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24379 temp2 = true;
24380 }
24381 if (obj2) {
24382 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24383 if (!SWIG_IsOK(ecode3)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_ToTimezone" "', expected argument " "3"" of type '" "bool""'");
24385 }
24386 arg3 = static_cast< bool >(val3);
24387 }
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24391 wxPyEndAllowThreads(__tstate);
24392 if (PyErr_Occurred()) SWIG_fail;
24393 }
24394 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24395 {
24396 if (temp2) delete arg2;
24397 }
24398 return resultobj;
24399 fail:
24400 {
24401 if (temp2) delete arg2;
24402 }
24403 return NULL;
24404 }
24405
24406
24407 SWIGINTERN PyObject *_wrap_DateTime_MakeTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24408 PyObject *resultobj = 0;
24409 wxDateTime *arg1 = (wxDateTime *) 0 ;
24410 wxDateTime::TimeZone *arg2 = 0 ;
24411 bool arg3 = (bool) false ;
24412 wxDateTime *result = 0 ;
24413 void *argp1 = 0 ;
24414 int res1 = 0 ;
24415 bool temp2 = false ;
24416 bool val3 ;
24417 int ecode3 = 0 ;
24418 PyObject * obj0 = 0 ;
24419 PyObject * obj1 = 0 ;
24420 PyObject * obj2 = 0 ;
24421 char * kwnames[] = {
24422 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24423 };
24424
24425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24427 if (!SWIG_IsOK(res1)) {
24428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24429 }
24430 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24431 {
24432 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24433 temp2 = true;
24434 }
24435 if (obj2) {
24436 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24437 if (!SWIG_IsOK(ecode3)) {
24438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeTimezone" "', expected argument " "3"" of type '" "bool""'");
24439 }
24440 arg3 = static_cast< bool >(val3);
24441 }
24442 {
24443 PyThreadState* __tstate = wxPyBeginAllowThreads();
24444 {
24445 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24446 result = (wxDateTime *) &_result_ref;
24447 }
24448 wxPyEndAllowThreads(__tstate);
24449 if (PyErr_Occurred()) SWIG_fail;
24450 }
24451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24452 {
24453 if (temp2) delete arg2;
24454 }
24455 return resultobj;
24456 fail:
24457 {
24458 if (temp2) delete arg2;
24459 }
24460 return NULL;
24461 }
24462
24463
24464 SWIGINTERN PyObject *_wrap_DateTime_FromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24465 PyObject *resultobj = 0;
24466 wxDateTime *arg1 = (wxDateTime *) 0 ;
24467 wxDateTime::TimeZone *arg2 = 0 ;
24468 bool arg3 = (bool) false ;
24469 wxDateTime result;
24470 void *argp1 = 0 ;
24471 int res1 = 0 ;
24472 bool temp2 = false ;
24473 bool val3 ;
24474 int ecode3 = 0 ;
24475 PyObject * obj0 = 0 ;
24476 PyObject * obj1 = 0 ;
24477 PyObject * obj2 = 0 ;
24478 char * kwnames[] = {
24479 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24480 };
24481
24482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_FromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24484 if (!SWIG_IsOK(res1)) {
24485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromTimezone" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24486 }
24487 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24488 {
24489 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24490 temp2 = true;
24491 }
24492 if (obj2) {
24493 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24494 if (!SWIG_IsOK(ecode3)) {
24495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_FromTimezone" "', expected argument " "3"" of type '" "bool""'");
24496 }
24497 arg3 = static_cast< bool >(val3);
24498 }
24499 {
24500 PyThreadState* __tstate = wxPyBeginAllowThreads();
24501 result = ((wxDateTime const *)arg1)->FromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24502 wxPyEndAllowThreads(__tstate);
24503 if (PyErr_Occurred()) SWIG_fail;
24504 }
24505 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24506 {
24507 if (temp2) delete arg2;
24508 }
24509 return resultobj;
24510 fail:
24511 {
24512 if (temp2) delete arg2;
24513 }
24514 return NULL;
24515 }
24516
24517
24518 SWIGINTERN PyObject *_wrap_DateTime_MakeFromTimezone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24519 PyObject *resultobj = 0;
24520 wxDateTime *arg1 = (wxDateTime *) 0 ;
24521 wxDateTime::TimeZone *arg2 = 0 ;
24522 bool arg3 = (bool) false ;
24523 wxDateTime *result = 0 ;
24524 void *argp1 = 0 ;
24525 int res1 = 0 ;
24526 bool temp2 = false ;
24527 bool val3 ;
24528 int ecode3 = 0 ;
24529 PyObject * obj0 = 0 ;
24530 PyObject * obj1 = 0 ;
24531 PyObject * obj2 = 0 ;
24532 char * kwnames[] = {
24533 (char *) "self",(char *) "tz",(char *) "noDST", NULL
24534 };
24535
24536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeFromTimezone",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24538 if (!SWIG_IsOK(res1)) {
24539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "1"" of type '" "wxDateTime *""'");
24540 }
24541 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24542 {
24543 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24544 temp2 = true;
24545 }
24546 if (obj2) {
24547 ecode3 = SWIG_AsVal_bool(obj2, &val3);
24548 if (!SWIG_IsOK(ecode3)) {
24549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DateTime_MakeFromTimezone" "', expected argument " "3"" of type '" "bool""'");
24550 }
24551 arg3 = static_cast< bool >(val3);
24552 }
24553 {
24554 PyThreadState* __tstate = wxPyBeginAllowThreads();
24555 {
24556 wxDateTime &_result_ref = (arg1)->MakeFromTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
24557 result = (wxDateTime *) &_result_ref;
24558 }
24559 wxPyEndAllowThreads(__tstate);
24560 if (PyErr_Occurred()) SWIG_fail;
24561 }
24562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24563 {
24564 if (temp2) delete arg2;
24565 }
24566 return resultobj;
24567 fail:
24568 {
24569 if (temp2) delete arg2;
24570 }
24571 return NULL;
24572 }
24573
24574
24575 SWIGINTERN PyObject *_wrap_DateTime_ToUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24576 PyObject *resultobj = 0;
24577 wxDateTime *arg1 = (wxDateTime *) 0 ;
24578 bool arg2 = (bool) false ;
24579 wxDateTime result;
24580 void *argp1 = 0 ;
24581 int res1 = 0 ;
24582 bool val2 ;
24583 int ecode2 = 0 ;
24584 PyObject * obj0 = 0 ;
24585 PyObject * obj1 = 0 ;
24586 char * kwnames[] = {
24587 (char *) "self",(char *) "noDST", NULL
24588 };
24589
24590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24592 if (!SWIG_IsOK(res1)) {
24593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24594 }
24595 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24596 if (obj1) {
24597 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24598 if (!SWIG_IsOK(ecode2)) {
24599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToUTC" "', expected argument " "2"" of type '" "bool""'");
24600 }
24601 arg2 = static_cast< bool >(val2);
24602 }
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 result = ((wxDateTime const *)arg1)->ToUTC(arg2);
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24610 return resultobj;
24611 fail:
24612 return NULL;
24613 }
24614
24615
24616 SWIGINTERN PyObject *_wrap_DateTime_MakeUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj = 0;
24618 wxDateTime *arg1 = (wxDateTime *) 0 ;
24619 bool arg2 = (bool) false ;
24620 wxDateTime *result = 0 ;
24621 void *argp1 = 0 ;
24622 int res1 = 0 ;
24623 bool val2 ;
24624 int ecode2 = 0 ;
24625 PyObject * obj0 = 0 ;
24626 PyObject * obj1 = 0 ;
24627 char * kwnames[] = {
24628 (char *) "self",(char *) "noDST", NULL
24629 };
24630
24631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24633 if (!SWIG_IsOK(res1)) {
24634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24635 }
24636 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24637 if (obj1) {
24638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24639 if (!SWIG_IsOK(ecode2)) {
24640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeUTC" "', expected argument " "2"" of type '" "bool""'");
24641 }
24642 arg2 = static_cast< bool >(val2);
24643 }
24644 {
24645 PyThreadState* __tstate = wxPyBeginAllowThreads();
24646 {
24647 wxDateTime &_result_ref = (arg1)->MakeUTC(arg2);
24648 result = (wxDateTime *) &_result_ref;
24649 }
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 SWIGINTERN PyObject *_wrap_DateTime_ToGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj = 0;
24662 wxDateTime *arg1 = (wxDateTime *) 0 ;
24663 bool arg2 = (bool) false ;
24664 wxDateTime result;
24665 void *argp1 = 0 ;
24666 int res1 = 0 ;
24667 bool val2 ;
24668 int ecode2 = 0 ;
24669 PyObject * obj0 = 0 ;
24670 PyObject * obj1 = 0 ;
24671 char * kwnames[] = {
24672 (char *) "self",(char *) "noDST", NULL
24673 };
24674
24675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24677 if (!SWIG_IsOK(res1)) {
24678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ToGMT" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24679 }
24680 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24681 if (obj1) {
24682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24683 if (!SWIG_IsOK(ecode2)) {
24684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_ToGMT" "', expected argument " "2"" of type '" "bool""'");
24685 }
24686 arg2 = static_cast< bool >(val2);
24687 }
24688 {
24689 PyThreadState* __tstate = wxPyBeginAllowThreads();
24690 result = ((wxDateTime const *)arg1)->ToGMT(arg2);
24691 wxPyEndAllowThreads(__tstate);
24692 if (PyErr_Occurred()) SWIG_fail;
24693 }
24694 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24695 return resultobj;
24696 fail:
24697 return NULL;
24698 }
24699
24700
24701 SWIGINTERN PyObject *_wrap_DateTime_MakeGMT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24702 PyObject *resultobj = 0;
24703 wxDateTime *arg1 = (wxDateTime *) 0 ;
24704 bool arg2 = (bool) false ;
24705 wxDateTime *result = 0 ;
24706 void *argp1 = 0 ;
24707 int res1 = 0 ;
24708 bool val2 ;
24709 int ecode2 = 0 ;
24710 PyObject * obj0 = 0 ;
24711 PyObject * obj1 = 0 ;
24712 char * kwnames[] = {
24713 (char *) "self",(char *) "noDST", NULL
24714 };
24715
24716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) SWIG_fail;
24717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24718 if (!SWIG_IsOK(res1)) {
24719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeGMT" "', expected argument " "1"" of type '" "wxDateTime *""'");
24720 }
24721 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24722 if (obj1) {
24723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24724 if (!SWIG_IsOK(ecode2)) {
24725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeGMT" "', expected argument " "2"" of type '" "bool""'");
24726 }
24727 arg2 = static_cast< bool >(val2);
24728 }
24729 {
24730 PyThreadState* __tstate = wxPyBeginAllowThreads();
24731 {
24732 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
24733 result = (wxDateTime *) &_result_ref;
24734 }
24735 wxPyEndAllowThreads(__tstate);
24736 if (PyErr_Occurred()) SWIG_fail;
24737 }
24738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24739 return resultobj;
24740 fail:
24741 return NULL;
24742 }
24743
24744
24745 SWIGINTERN PyObject *_wrap_DateTime_FromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24746 PyObject *resultobj = 0;
24747 wxDateTime *arg1 = (wxDateTime *) 0 ;
24748 bool arg2 = (bool) false ;
24749 wxDateTime result;
24750 void *argp1 = 0 ;
24751 int res1 = 0 ;
24752 bool val2 ;
24753 int ecode2 = 0 ;
24754 PyObject * obj0 = 0 ;
24755 PyObject * obj1 = 0 ;
24756 char * kwnames[] = {
24757 (char *) "self",(char *) "noDST", NULL
24758 };
24759
24760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_FromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24762 if (!SWIG_IsOK(res1)) {
24763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FromUTC" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24764 }
24765 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24766 if (obj1) {
24767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24768 if (!SWIG_IsOK(ecode2)) {
24769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_FromUTC" "', expected argument " "2"" of type '" "bool""'");
24770 }
24771 arg2 = static_cast< bool >(val2);
24772 }
24773 {
24774 PyThreadState* __tstate = wxPyBeginAllowThreads();
24775 result = ((wxDateTime const *)arg1)->FromUTC(arg2);
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 SWIGINTERN PyObject *_wrap_DateTime_MakeFromUTC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24787 PyObject *resultobj = 0;
24788 wxDateTime *arg1 = (wxDateTime *) 0 ;
24789 bool arg2 = (bool) false ;
24790 wxDateTime *result = 0 ;
24791 void *argp1 = 0 ;
24792 int res1 = 0 ;
24793 bool val2 ;
24794 int ecode2 = 0 ;
24795 PyObject * obj0 = 0 ;
24796 PyObject * obj1 = 0 ;
24797 char * kwnames[] = {
24798 (char *) "self",(char *) "noDST", NULL
24799 };
24800
24801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeFromUTC",kwnames,&obj0,&obj1)) SWIG_fail;
24802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24803 if (!SWIG_IsOK(res1)) {
24804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_MakeFromUTC" "', expected argument " "1"" of type '" "wxDateTime *""'");
24805 }
24806 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24807 if (obj1) {
24808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24809 if (!SWIG_IsOK(ecode2)) {
24810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_MakeFromUTC" "', expected argument " "2"" of type '" "bool""'");
24811 }
24812 arg2 = static_cast< bool >(val2);
24813 }
24814 {
24815 PyThreadState* __tstate = wxPyBeginAllowThreads();
24816 {
24817 wxDateTime &_result_ref = (arg1)->MakeFromUTC(arg2);
24818 result = (wxDateTime *) &_result_ref;
24819 }
24820 wxPyEndAllowThreads(__tstate);
24821 if (PyErr_Occurred()) SWIG_fail;
24822 }
24823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
24824 return resultobj;
24825 fail:
24826 return NULL;
24827 }
24828
24829
24830 SWIGINTERN PyObject *_wrap_DateTime_IsDST(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24831 PyObject *resultobj = 0;
24832 wxDateTime *arg1 = (wxDateTime *) 0 ;
24833 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
24834 int result;
24835 void *argp1 = 0 ;
24836 int res1 = 0 ;
24837 int val2 ;
24838 int ecode2 = 0 ;
24839 PyObject * obj0 = 0 ;
24840 PyObject * obj1 = 0 ;
24841 char * kwnames[] = {
24842 (char *) "self",(char *) "country", NULL
24843 };
24844
24845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) SWIG_fail;
24846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24847 if (!SWIG_IsOK(res1)) {
24848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsDST" "', expected argument " "1"" of type '" "wxDateTime *""'");
24849 }
24850 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24851 if (obj1) {
24852 ecode2 = SWIG_AsVal_int(obj1, &val2);
24853 if (!SWIG_IsOK(ecode2)) {
24854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsDST" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
24855 }
24856 arg2 = static_cast< wxDateTime::Country >(val2);
24857 }
24858 {
24859 PyThreadState* __tstate = wxPyBeginAllowThreads();
24860 result = (int)(arg1)->IsDST(arg2);
24861 wxPyEndAllowThreads(__tstate);
24862 if (PyErr_Occurred()) SWIG_fail;
24863 }
24864 resultobj = SWIG_From_int(static_cast< int >(result));
24865 return resultobj;
24866 fail:
24867 return NULL;
24868 }
24869
24870
24871 SWIGINTERN PyObject *_wrap_DateTime_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24872 PyObject *resultobj = 0;
24873 wxDateTime *arg1 = (wxDateTime *) 0 ;
24874 bool result;
24875 void *argp1 = 0 ;
24876 int res1 = 0 ;
24877 PyObject *swig_obj[1] ;
24878
24879 if (!args) SWIG_fail;
24880 swig_obj[0] = args;
24881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24882 if (!SWIG_IsOK(res1)) {
24883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsValid" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24884 }
24885 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24886 {
24887 PyThreadState* __tstate = wxPyBeginAllowThreads();
24888 result = (bool)((wxDateTime const *)arg1)->IsValid();
24889 wxPyEndAllowThreads(__tstate);
24890 if (PyErr_Occurred()) SWIG_fail;
24891 }
24892 {
24893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24894 }
24895 return resultobj;
24896 fail:
24897 return NULL;
24898 }
24899
24900
24901 SWIGINTERN PyObject *_wrap_DateTime_GetTicks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24902 PyObject *resultobj = 0;
24903 wxDateTime *arg1 = (wxDateTime *) 0 ;
24904 time_t result;
24905 void *argp1 = 0 ;
24906 int res1 = 0 ;
24907 PyObject *swig_obj[1] ;
24908
24909 if (!args) SWIG_fail;
24910 swig_obj[0] = args;
24911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24912 if (!SWIG_IsOK(res1)) {
24913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetTicks" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24914 }
24915 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24916 {
24917 PyThreadState* __tstate = wxPyBeginAllowThreads();
24918 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
24919 wxPyEndAllowThreads(__tstate);
24920 if (PyErr_Occurred()) SWIG_fail;
24921 }
24922 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 SWIGINTERN PyObject *_wrap_DateTime_GetYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj = 0;
24931 wxDateTime *arg1 = (wxDateTime *) 0 ;
24932 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24933 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24934 int result;
24935 void *argp1 = 0 ;
24936 int res1 = 0 ;
24937 bool temp2 = false ;
24938 PyObject * obj0 = 0 ;
24939 PyObject * obj1 = 0 ;
24940 char * kwnames[] = {
24941 (char *) "self",(char *) "tz", NULL
24942 };
24943
24944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) SWIG_fail;
24945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24946 if (!SWIG_IsOK(res1)) {
24947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24948 }
24949 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24950 if (obj1) {
24951 {
24952 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24953 temp2 = true;
24954 }
24955 }
24956 {
24957 PyThreadState* __tstate = wxPyBeginAllowThreads();
24958 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
24959 wxPyEndAllowThreads(__tstate);
24960 if (PyErr_Occurred()) SWIG_fail;
24961 }
24962 resultobj = SWIG_From_int(static_cast< int >(result));
24963 {
24964 if (temp2) delete arg2;
24965 }
24966 return resultobj;
24967 fail:
24968 {
24969 if (temp2) delete arg2;
24970 }
24971 return NULL;
24972 }
24973
24974
24975 SWIGINTERN PyObject *_wrap_DateTime_GetMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24976 PyObject *resultobj = 0;
24977 wxDateTime *arg1 = (wxDateTime *) 0 ;
24978 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
24979 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
24980 wxDateTime::Month result;
24981 void *argp1 = 0 ;
24982 int res1 = 0 ;
24983 bool temp2 = false ;
24984 PyObject * obj0 = 0 ;
24985 PyObject * obj1 = 0 ;
24986 char * kwnames[] = {
24987 (char *) "self",(char *) "tz", NULL
24988 };
24989
24990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) SWIG_fail;
24991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
24992 if (!SWIG_IsOK(res1)) {
24993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
24994 }
24995 arg1 = reinterpret_cast< wxDateTime * >(argp1);
24996 if (obj1) {
24997 {
24998 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
24999 temp2 = true;
25000 }
25001 }
25002 {
25003 PyThreadState* __tstate = wxPyBeginAllowThreads();
25004 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
25005 wxPyEndAllowThreads(__tstate);
25006 if (PyErr_Occurred()) SWIG_fail;
25007 }
25008 resultobj = SWIG_From_int(static_cast< int >(result));
25009 {
25010 if (temp2) delete arg2;
25011 }
25012 return resultobj;
25013 fail:
25014 {
25015 if (temp2) delete arg2;
25016 }
25017 return NULL;
25018 }
25019
25020
25021 SWIGINTERN PyObject *_wrap_DateTime_GetDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25022 PyObject *resultobj = 0;
25023 wxDateTime *arg1 = (wxDateTime *) 0 ;
25024 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25025 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25026 int result;
25027 void *argp1 = 0 ;
25028 int res1 = 0 ;
25029 bool temp2 = false ;
25030 PyObject * obj0 = 0 ;
25031 PyObject * obj1 = 0 ;
25032 char * kwnames[] = {
25033 (char *) "self",(char *) "tz", NULL
25034 };
25035
25036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) SWIG_fail;
25037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25040 }
25041 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25042 if (obj1) {
25043 {
25044 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25045 temp2 = true;
25046 }
25047 }
25048 {
25049 PyThreadState* __tstate = wxPyBeginAllowThreads();
25050 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
25051 wxPyEndAllowThreads(__tstate);
25052 if (PyErr_Occurred()) SWIG_fail;
25053 }
25054 resultobj = SWIG_From_int(static_cast< int >(result));
25055 {
25056 if (temp2) delete arg2;
25057 }
25058 return resultobj;
25059 fail:
25060 {
25061 if (temp2) delete arg2;
25062 }
25063 return NULL;
25064 }
25065
25066
25067 SWIGINTERN PyObject *_wrap_DateTime_GetWeekDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25068 PyObject *resultobj = 0;
25069 wxDateTime *arg1 = (wxDateTime *) 0 ;
25070 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25071 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25072 wxDateTime::WeekDay result;
25073 void *argp1 = 0 ;
25074 int res1 = 0 ;
25075 bool temp2 = false ;
25076 PyObject * obj0 = 0 ;
25077 PyObject * obj1 = 0 ;
25078 char * kwnames[] = {
25079 (char *) "self",(char *) "tz", NULL
25080 };
25081
25082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) SWIG_fail;
25083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25084 if (!SWIG_IsOK(res1)) {
25085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25086 }
25087 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25088 if (obj1) {
25089 {
25090 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25091 temp2 = true;
25092 }
25093 }
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 resultobj = SWIG_From_int(static_cast< int >(result));
25101 {
25102 if (temp2) delete arg2;
25103 }
25104 return resultobj;
25105 fail:
25106 {
25107 if (temp2) delete arg2;
25108 }
25109 return NULL;
25110 }
25111
25112
25113 SWIGINTERN PyObject *_wrap_DateTime_GetHour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25114 PyObject *resultobj = 0;
25115 wxDateTime *arg1 = (wxDateTime *) 0 ;
25116 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25117 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25118 int result;
25119 void *argp1 = 0 ;
25120 int res1 = 0 ;
25121 bool temp2 = false ;
25122 PyObject * obj0 = 0 ;
25123 PyObject * obj1 = 0 ;
25124 char * kwnames[] = {
25125 (char *) "self",(char *) "tz", NULL
25126 };
25127
25128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) SWIG_fail;
25129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25130 if (!SWIG_IsOK(res1)) {
25131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetHour" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25132 }
25133 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25134 if (obj1) {
25135 {
25136 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25137 temp2 = true;
25138 }
25139 }
25140 {
25141 PyThreadState* __tstate = wxPyBeginAllowThreads();
25142 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
25143 wxPyEndAllowThreads(__tstate);
25144 if (PyErr_Occurred()) SWIG_fail;
25145 }
25146 resultobj = SWIG_From_int(static_cast< int >(result));
25147 {
25148 if (temp2) delete arg2;
25149 }
25150 return resultobj;
25151 fail:
25152 {
25153 if (temp2) delete arg2;
25154 }
25155 return NULL;
25156 }
25157
25158
25159 SWIGINTERN PyObject *_wrap_DateTime_GetMinute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25160 PyObject *resultobj = 0;
25161 wxDateTime *arg1 = (wxDateTime *) 0 ;
25162 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25163 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25164 int result;
25165 void *argp1 = 0 ;
25166 int res1 = 0 ;
25167 bool temp2 = false ;
25168 PyObject * obj0 = 0 ;
25169 PyObject * obj1 = 0 ;
25170 char * kwnames[] = {
25171 (char *) "self",(char *) "tz", NULL
25172 };
25173
25174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) SWIG_fail;
25175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25176 if (!SWIG_IsOK(res1)) {
25177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMinute" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25178 }
25179 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25180 if (obj1) {
25181 {
25182 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25183 temp2 = true;
25184 }
25185 }
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 resultobj = SWIG_From_int(static_cast< int >(result));
25193 {
25194 if (temp2) delete arg2;
25195 }
25196 return resultobj;
25197 fail:
25198 {
25199 if (temp2) delete arg2;
25200 }
25201 return NULL;
25202 }
25203
25204
25205 SWIGINTERN PyObject *_wrap_DateTime_GetSecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25206 PyObject *resultobj = 0;
25207 wxDateTime *arg1 = (wxDateTime *) 0 ;
25208 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25209 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25210 int result;
25211 void *argp1 = 0 ;
25212 int res1 = 0 ;
25213 bool temp2 = false ;
25214 PyObject * obj0 = 0 ;
25215 PyObject * obj1 = 0 ;
25216 char * kwnames[] = {
25217 (char *) "self",(char *) "tz", NULL
25218 };
25219
25220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) SWIG_fail;
25221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25222 if (!SWIG_IsOK(res1)) {
25223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetSecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25224 }
25225 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25226 if (obj1) {
25227 {
25228 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25229 temp2 = true;
25230 }
25231 }
25232 {
25233 PyThreadState* __tstate = wxPyBeginAllowThreads();
25234 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
25235 wxPyEndAllowThreads(__tstate);
25236 if (PyErr_Occurred()) SWIG_fail;
25237 }
25238 resultobj = SWIG_From_int(static_cast< int >(result));
25239 {
25240 if (temp2) delete arg2;
25241 }
25242 return resultobj;
25243 fail:
25244 {
25245 if (temp2) delete arg2;
25246 }
25247 return NULL;
25248 }
25249
25250
25251 SWIGINTERN PyObject *_wrap_DateTime_GetMillisecond(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj = 0;
25253 wxDateTime *arg1 = (wxDateTime *) 0 ;
25254 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25255 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25256 int result;
25257 void *argp1 = 0 ;
25258 int res1 = 0 ;
25259 bool temp2 = false ;
25260 PyObject * obj0 = 0 ;
25261 PyObject * obj1 = 0 ;
25262 char * kwnames[] = {
25263 (char *) "self",(char *) "tz", NULL
25264 };
25265
25266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) SWIG_fail;
25267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25268 if (!SWIG_IsOK(res1)) {
25269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetMillisecond" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25270 }
25271 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25272 if (obj1) {
25273 {
25274 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25275 temp2 = true;
25276 }
25277 }
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 resultobj = SWIG_From_int(static_cast< int >(result));
25285 {
25286 if (temp2) delete arg2;
25287 }
25288 return resultobj;
25289 fail:
25290 {
25291 if (temp2) delete arg2;
25292 }
25293 return NULL;
25294 }
25295
25296
25297 SWIGINTERN PyObject *_wrap_DateTime_GetDayOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25298 PyObject *resultobj = 0;
25299 wxDateTime *arg1 = (wxDateTime *) 0 ;
25300 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
25301 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
25302 int result;
25303 void *argp1 = 0 ;
25304 int res1 = 0 ;
25305 bool temp2 = false ;
25306 PyObject * obj0 = 0 ;
25307 PyObject * obj1 = 0 ;
25308 char * kwnames[] = {
25309 (char *) "self",(char *) "tz", NULL
25310 };
25311
25312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) SWIG_fail;
25313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25314 if (!SWIG_IsOK(res1)) {
25315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetDayOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25316 }
25317 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25318 if (obj1) {
25319 {
25320 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
25321 temp2 = true;
25322 }
25323 }
25324 {
25325 PyThreadState* __tstate = wxPyBeginAllowThreads();
25326 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
25327 wxPyEndAllowThreads(__tstate);
25328 if (PyErr_Occurred()) SWIG_fail;
25329 }
25330 resultobj = SWIG_From_int(static_cast< int >(result));
25331 {
25332 if (temp2) delete arg2;
25333 }
25334 return resultobj;
25335 fail:
25336 {
25337 if (temp2) delete arg2;
25338 }
25339 return NULL;
25340 }
25341
25342
25343 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25344 PyObject *resultobj = 0;
25345 wxDateTime *arg1 = (wxDateTime *) 0 ;
25346 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25347 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25348 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25349 int result;
25350 void *argp1 = 0 ;
25351 int res1 = 0 ;
25352 int val2 ;
25353 int ecode2 = 0 ;
25354 bool temp3 = false ;
25355 PyObject * obj0 = 0 ;
25356 PyObject * obj1 = 0 ;
25357 PyObject * obj2 = 0 ;
25358 char * kwnames[] = {
25359 (char *) "self",(char *) "flags",(char *) "tz", NULL
25360 };
25361
25362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25364 if (!SWIG_IsOK(res1)) {
25365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25366 }
25367 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25368 if (obj1) {
25369 ecode2 = SWIG_AsVal_int(obj1, &val2);
25370 if (!SWIG_IsOK(ecode2)) {
25371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfYear" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25372 }
25373 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25374 }
25375 if (obj2) {
25376 {
25377 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25378 temp3 = true;
25379 }
25380 }
25381 {
25382 PyThreadState* __tstate = wxPyBeginAllowThreads();
25383 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear(arg2,(wxDateTime::TimeZone const &)*arg3);
25384 wxPyEndAllowThreads(__tstate);
25385 if (PyErr_Occurred()) SWIG_fail;
25386 }
25387 resultobj = SWIG_From_int(static_cast< int >(result));
25388 {
25389 if (temp3) delete arg3;
25390 }
25391 return resultobj;
25392 fail:
25393 {
25394 if (temp3) delete arg3;
25395 }
25396 return NULL;
25397 }
25398
25399
25400 SWIGINTERN PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25401 PyObject *resultobj = 0;
25402 wxDateTime *arg1 = (wxDateTime *) 0 ;
25403 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
25404 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
25405 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
25406 int result;
25407 void *argp1 = 0 ;
25408 int res1 = 0 ;
25409 int val2 ;
25410 int ecode2 = 0 ;
25411 bool temp3 = false ;
25412 PyObject * obj0 = 0 ;
25413 PyObject * obj1 = 0 ;
25414 PyObject * obj2 = 0 ;
25415 char * kwnames[] = {
25416 (char *) "self",(char *) "flags",(char *) "tz", NULL
25417 };
25418
25419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25421 if (!SWIG_IsOK(res1)) {
25422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25423 }
25424 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25425 if (obj1) {
25426 ecode2 = SWIG_AsVal_int(obj1, &val2);
25427 if (!SWIG_IsOK(ecode2)) {
25428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_GetWeekOfMonth" "', expected argument " "2"" of type '" "wxDateTime::WeekFlags""'");
25429 }
25430 arg2 = static_cast< wxDateTime::WeekFlags >(val2);
25431 }
25432 if (obj2) {
25433 {
25434 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
25435 temp3 = true;
25436 }
25437 }
25438 {
25439 PyThreadState* __tstate = wxPyBeginAllowThreads();
25440 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth(arg2,(wxDateTime::TimeZone const &)*arg3);
25441 wxPyEndAllowThreads(__tstate);
25442 if (PyErr_Occurred()) SWIG_fail;
25443 }
25444 resultobj = SWIG_From_int(static_cast< int >(result));
25445 {
25446 if (temp3) delete arg3;
25447 }
25448 return resultobj;
25449 fail:
25450 {
25451 if (temp3) delete arg3;
25452 }
25453 return NULL;
25454 }
25455
25456
25457 SWIGINTERN PyObject *_wrap_DateTime_IsWorkDay(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25458 PyObject *resultobj = 0;
25459 wxDateTime *arg1 = (wxDateTime *) 0 ;
25460 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
25461 bool result;
25462 void *argp1 = 0 ;
25463 int res1 = 0 ;
25464 int val2 ;
25465 int ecode2 = 0 ;
25466 PyObject * obj0 = 0 ;
25467 PyObject * obj1 = 0 ;
25468 char * kwnames[] = {
25469 (char *) "self",(char *) "country", NULL
25470 };
25471
25472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) SWIG_fail;
25473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25474 if (!SWIG_IsOK(res1)) {
25475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsWorkDay" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25476 }
25477 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25478 if (obj1) {
25479 ecode2 = SWIG_AsVal_int(obj1, &val2);
25480 if (!SWIG_IsOK(ecode2)) {
25481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateTime_IsWorkDay" "', expected argument " "2"" of type '" "wxDateTime::Country""'");
25482 }
25483 arg2 = static_cast< wxDateTime::Country >(val2);
25484 }
25485 {
25486 PyThreadState* __tstate = wxPyBeginAllowThreads();
25487 result = (bool)((wxDateTime const *)arg1)->IsWorkDay(arg2);
25488 wxPyEndAllowThreads(__tstate);
25489 if (PyErr_Occurred()) SWIG_fail;
25490 }
25491 {
25492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25493 }
25494 return resultobj;
25495 fail:
25496 return NULL;
25497 }
25498
25499
25500 SWIGINTERN PyObject *_wrap_DateTime_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25501 PyObject *resultobj = 0;
25502 wxDateTime *arg1 = (wxDateTime *) 0 ;
25503 wxDateTime *arg2 = 0 ;
25504 bool result;
25505 void *argp1 = 0 ;
25506 int res1 = 0 ;
25507 void *argp2 = 0 ;
25508 int res2 = 0 ;
25509 PyObject * obj0 = 0 ;
25510 PyObject * obj1 = 0 ;
25511 char * kwnames[] = {
25512 (char *) "self",(char *) "datetime", NULL
25513 };
25514
25515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
25516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25517 if (!SWIG_IsOK(res1)) {
25518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25519 }
25520 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25521 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25522 if (!SWIG_IsOK(res2)) {
25523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25524 }
25525 if (!argp2) {
25526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25527 }
25528 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 {
25536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25537 }
25538 return resultobj;
25539 fail:
25540 return NULL;
25541 }
25542
25543
25544 SWIGINTERN PyObject *_wrap_DateTime_IsEarlierThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25545 PyObject *resultobj = 0;
25546 wxDateTime *arg1 = (wxDateTime *) 0 ;
25547 wxDateTime *arg2 = 0 ;
25548 bool result;
25549 void *argp1 = 0 ;
25550 int res1 = 0 ;
25551 void *argp2 = 0 ;
25552 int res2 = 0 ;
25553 PyObject * obj0 = 0 ;
25554 PyObject * obj1 = 0 ;
25555 char * kwnames[] = {
25556 (char *) "self",(char *) "datetime", NULL
25557 };
25558
25559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) SWIG_fail;
25560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25561 if (!SWIG_IsOK(res1)) {
25562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEarlierThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25563 }
25564 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25565 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25566 if (!SWIG_IsOK(res2)) {
25567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25568 }
25569 if (!argp2) {
25570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEarlierThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25571 }
25572 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
25576 wxPyEndAllowThreads(__tstate);
25577 if (PyErr_Occurred()) SWIG_fail;
25578 }
25579 {
25580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25581 }
25582 return resultobj;
25583 fail:
25584 return NULL;
25585 }
25586
25587
25588 SWIGINTERN PyObject *_wrap_DateTime_IsLaterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25589 PyObject *resultobj = 0;
25590 wxDateTime *arg1 = (wxDateTime *) 0 ;
25591 wxDateTime *arg2 = 0 ;
25592 bool result;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 void *argp2 = 0 ;
25596 int res2 = 0 ;
25597 PyObject * obj0 = 0 ;
25598 PyObject * obj1 = 0 ;
25599 char * kwnames[] = {
25600 (char *) "self",(char *) "datetime", NULL
25601 };
25602
25603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) SWIG_fail;
25604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25605 if (!SWIG_IsOK(res1)) {
25606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsLaterThan" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25607 }
25608 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25610 if (!SWIG_IsOK(res2)) {
25611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25612 }
25613 if (!argp2) {
25614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsLaterThan" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25615 }
25616 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25617 {
25618 PyThreadState* __tstate = wxPyBeginAllowThreads();
25619 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
25620 wxPyEndAllowThreads(__tstate);
25621 if (PyErr_Occurred()) SWIG_fail;
25622 }
25623 {
25624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25625 }
25626 return resultobj;
25627 fail:
25628 return NULL;
25629 }
25630
25631
25632 SWIGINTERN PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25633 PyObject *resultobj = 0;
25634 wxDateTime *arg1 = (wxDateTime *) 0 ;
25635 wxDateTime *arg2 = 0 ;
25636 wxDateTime *arg3 = 0 ;
25637 bool result;
25638 void *argp1 = 0 ;
25639 int res1 = 0 ;
25640 void *argp2 = 0 ;
25641 int res2 = 0 ;
25642 void *argp3 = 0 ;
25643 int res3 = 0 ;
25644 PyObject * obj0 = 0 ;
25645 PyObject * obj1 = 0 ;
25646 PyObject * obj2 = 0 ;
25647 char * kwnames[] = {
25648 (char *) "self",(char *) "t1",(char *) "t2", NULL
25649 };
25650
25651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25653 if (!SWIG_IsOK(res1)) {
25654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25655 }
25656 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25657 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25658 if (!SWIG_IsOK(res2)) {
25659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25660 }
25661 if (!argp2) {
25662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25663 }
25664 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25665 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25666 if (!SWIG_IsOK(res3)) {
25667 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25668 }
25669 if (!argp3) {
25670 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsStrictlyBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25671 }
25672 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25673 {
25674 PyThreadState* __tstate = wxPyBeginAllowThreads();
25675 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25676 wxPyEndAllowThreads(__tstate);
25677 if (PyErr_Occurred()) SWIG_fail;
25678 }
25679 {
25680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25681 }
25682 return resultobj;
25683 fail:
25684 return NULL;
25685 }
25686
25687
25688 SWIGINTERN PyObject *_wrap_DateTime_IsBetween(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25689 PyObject *resultobj = 0;
25690 wxDateTime *arg1 = (wxDateTime *) 0 ;
25691 wxDateTime *arg2 = 0 ;
25692 wxDateTime *arg3 = 0 ;
25693 bool result;
25694 void *argp1 = 0 ;
25695 int res1 = 0 ;
25696 void *argp2 = 0 ;
25697 int res2 = 0 ;
25698 void *argp3 = 0 ;
25699 int res3 = 0 ;
25700 PyObject * obj0 = 0 ;
25701 PyObject * obj1 = 0 ;
25702 PyObject * obj2 = 0 ;
25703 char * kwnames[] = {
25704 (char *) "self",(char *) "t1",(char *) "t2", NULL
25705 };
25706
25707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25709 if (!SWIG_IsOK(res1)) {
25710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsBetween" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25711 }
25712 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25713 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25714 if (!SWIG_IsOK(res2)) {
25715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25716 }
25717 if (!argp2) {
25718 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25719 }
25720 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25721 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDateTime, 0 | 0);
25722 if (!SWIG_IsOK(res3)) {
25723 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25724 }
25725 if (!argp3) {
25726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsBetween" "', expected argument " "3"" of type '" "wxDateTime const &""'");
25727 }
25728 arg3 = reinterpret_cast< wxDateTime * >(argp3);
25729 {
25730 PyThreadState* __tstate = wxPyBeginAllowThreads();
25731 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 {
25736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25737 }
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 SWIGINTERN PyObject *_wrap_DateTime_IsSameDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25745 PyObject *resultobj = 0;
25746 wxDateTime *arg1 = (wxDateTime *) 0 ;
25747 wxDateTime *arg2 = 0 ;
25748 bool result;
25749 void *argp1 = 0 ;
25750 int res1 = 0 ;
25751 void *argp2 = 0 ;
25752 int res2 = 0 ;
25753 PyObject * obj0 = 0 ;
25754 PyObject * obj1 = 0 ;
25755 char * kwnames[] = {
25756 (char *) "self",(char *) "dt", NULL
25757 };
25758
25759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) SWIG_fail;
25760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25761 if (!SWIG_IsOK(res1)) {
25762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25763 }
25764 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25766 if (!SWIG_IsOK(res2)) {
25767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25768 }
25769 if (!argp2) {
25770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25771 }
25772 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25773 {
25774 PyThreadState* __tstate = wxPyBeginAllowThreads();
25775 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
25776 wxPyEndAllowThreads(__tstate);
25777 if (PyErr_Occurred()) SWIG_fail;
25778 }
25779 {
25780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25781 }
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 SWIGINTERN PyObject *_wrap_DateTime_IsSameTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25789 PyObject *resultobj = 0;
25790 wxDateTime *arg1 = (wxDateTime *) 0 ;
25791 wxDateTime *arg2 = 0 ;
25792 bool result;
25793 void *argp1 = 0 ;
25794 int res1 = 0 ;
25795 void *argp2 = 0 ;
25796 int res2 = 0 ;
25797 PyObject * obj0 = 0 ;
25798 PyObject * obj1 = 0 ;
25799 char * kwnames[] = {
25800 (char *) "self",(char *) "dt", NULL
25801 };
25802
25803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) SWIG_fail;
25804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25805 if (!SWIG_IsOK(res1)) {
25806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsSameTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25807 }
25808 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25810 if (!SWIG_IsOK(res2)) {
25811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25812 }
25813 if (!argp2) {
25814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsSameTime" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25815 }
25816 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
25820 wxPyEndAllowThreads(__tstate);
25821 if (PyErr_Occurred()) SWIG_fail;
25822 }
25823 {
25824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25825 }
25826 return resultobj;
25827 fail:
25828 return NULL;
25829 }
25830
25831
25832 SWIGINTERN PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25833 PyObject *resultobj = 0;
25834 wxDateTime *arg1 = (wxDateTime *) 0 ;
25835 wxDateTime *arg2 = 0 ;
25836 wxTimeSpan *arg3 = 0 ;
25837 bool result;
25838 void *argp1 = 0 ;
25839 int res1 = 0 ;
25840 void *argp2 = 0 ;
25841 int res2 = 0 ;
25842 void *argp3 = 0 ;
25843 int res3 = 0 ;
25844 PyObject * obj0 = 0 ;
25845 PyObject * obj1 = 0 ;
25846 PyObject * obj2 = 0 ;
25847 char * kwnames[] = {
25848 (char *) "self",(char *) "dt",(char *) "ts", NULL
25849 };
25850
25851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25853 if (!SWIG_IsOK(res1)) {
25854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "1"" of type '" "wxDateTime const *""'");
25855 }
25856 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
25858 if (!SWIG_IsOK(res2)) {
25859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25860 }
25861 if (!argp2) {
25862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "2"" of type '" "wxDateTime const &""'");
25863 }
25864 arg2 = reinterpret_cast< wxDateTime * >(argp2);
25865 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25866 if (!SWIG_IsOK(res3)) {
25867 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25868 }
25869 if (!argp3) {
25870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_IsEqualUpTo" "', expected argument " "3"" of type '" "wxTimeSpan const &""'");
25871 }
25872 arg3 = reinterpret_cast< wxTimeSpan * >(argp3);
25873 {
25874 PyThreadState* __tstate = wxPyBeginAllowThreads();
25875 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
25876 wxPyEndAllowThreads(__tstate);
25877 if (PyErr_Occurred()) SWIG_fail;
25878 }
25879 {
25880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25881 }
25882 return resultobj;
25883 fail:
25884 return NULL;
25885 }
25886
25887
25888 SWIGINTERN PyObject *_wrap_DateTime_AddTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25889 PyObject *resultobj = 0;
25890 wxDateTime *arg1 = (wxDateTime *) 0 ;
25891 wxTimeSpan *arg2 = 0 ;
25892 wxDateTime *result = 0 ;
25893 void *argp1 = 0 ;
25894 int res1 = 0 ;
25895 void *argp2 = 0 ;
25896 int res2 = 0 ;
25897 PyObject * obj0 = 0 ;
25898 PyObject * obj1 = 0 ;
25899 char * kwnames[] = {
25900 (char *) "self",(char *) "diff", NULL
25901 };
25902
25903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) SWIG_fail;
25904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25905 if (!SWIG_IsOK(res1)) {
25906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25907 }
25908 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
25910 if (!SWIG_IsOK(res2)) {
25911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25912 }
25913 if (!argp2) {
25914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
25915 }
25916 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
25917 {
25918 PyThreadState* __tstate = wxPyBeginAllowThreads();
25919 {
25920 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
25921 result = (wxDateTime *) &_result_ref;
25922 }
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 SWIGINTERN PyObject *_wrap_DateTime_AddDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25934 PyObject *resultobj = 0;
25935 wxDateTime *arg1 = (wxDateTime *) 0 ;
25936 wxDateSpan *arg2 = 0 ;
25937 wxDateTime *result = 0 ;
25938 void *argp1 = 0 ;
25939 int res1 = 0 ;
25940 void *argp2 = 0 ;
25941 int res2 = 0 ;
25942 PyObject * obj0 = 0 ;
25943 PyObject * obj1 = 0 ;
25944 char * kwnames[] = {
25945 (char *) "self",(char *) "diff", NULL
25946 };
25947
25948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) SWIG_fail;
25949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25950 if (!SWIG_IsOK(res1)) {
25951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_AddDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25952 }
25953 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25954 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
25955 if (!SWIG_IsOK(res2)) {
25956 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25957 }
25958 if (!argp2) {
25959 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_AddDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
25960 }
25961 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
25962 {
25963 PyThreadState* __tstate = wxPyBeginAllowThreads();
25964 {
25965 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25966 result = (wxDateTime *) &_result_ref;
25967 }
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 SWIGINTERN PyObject *_wrap_DateTime_SubtractTS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj = 0;
25980 wxDateTime *arg1 = (wxDateTime *) 0 ;
25981 wxTimeSpan *arg2 = 0 ;
25982 wxDateTime *result = 0 ;
25983 void *argp1 = 0 ;
25984 int res1 = 0 ;
25985 void *argp2 = 0 ;
25986 int res2 = 0 ;
25987 PyObject * obj0 = 0 ;
25988 PyObject * obj1 = 0 ;
25989 char * kwnames[] = {
25990 (char *) "self",(char *) "diff", NULL
25991 };
25992
25993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) SWIG_fail;
25994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
25995 if (!SWIG_IsOK(res1)) {
25996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractTS" "', expected argument " "1"" of type '" "wxDateTime *""'");
25997 }
25998 arg1 = reinterpret_cast< wxDateTime * >(argp1);
25999 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26000 if (!SWIG_IsOK(res2)) {
26001 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26002 }
26003 if (!argp2) {
26004 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractTS" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26005 }
26006 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26007 {
26008 PyThreadState* __tstate = wxPyBeginAllowThreads();
26009 {
26010 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
26011 result = (wxDateTime *) &_result_ref;
26012 }
26013 wxPyEndAllowThreads(__tstate);
26014 if (PyErr_Occurred()) SWIG_fail;
26015 }
26016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 SWIGINTERN PyObject *_wrap_DateTime_SubtractDS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26024 PyObject *resultobj = 0;
26025 wxDateTime *arg1 = (wxDateTime *) 0 ;
26026 wxDateSpan *arg2 = 0 ;
26027 wxDateTime *result = 0 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 void *argp2 = 0 ;
26031 int res2 = 0 ;
26032 PyObject * obj0 = 0 ;
26033 PyObject * obj1 = 0 ;
26034 char * kwnames[] = {
26035 (char *) "self",(char *) "diff", NULL
26036 };
26037
26038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) SWIG_fail;
26039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_SubtractDS" "', expected argument " "1"" of type '" "wxDateTime *""'");
26042 }
26043 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26044 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26045 if (!SWIG_IsOK(res2)) {
26046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26047 }
26048 if (!argp2) {
26049 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_SubtractDS" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26050 }
26051 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26052 {
26053 PyThreadState* __tstate = wxPyBeginAllowThreads();
26054 {
26055 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
26056 result = (wxDateTime *) &_result_ref;
26057 }
26058 wxPyEndAllowThreads(__tstate);
26059 if (PyErr_Occurred()) SWIG_fail;
26060 }
26061 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26062 return resultobj;
26063 fail:
26064 return NULL;
26065 }
26066
26067
26068 SWIGINTERN PyObject *_wrap_DateTime_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26069 PyObject *resultobj = 0;
26070 wxDateTime *arg1 = (wxDateTime *) 0 ;
26071 wxDateTime *arg2 = 0 ;
26072 wxTimeSpan result;
26073 void *argp1 = 0 ;
26074 int res1 = 0 ;
26075 void *argp2 = 0 ;
26076 int res2 = 0 ;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char * kwnames[] = {
26080 (char *) "self",(char *) "dt", NULL
26081 };
26082
26083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
26084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26085 if (!SWIG_IsOK(res1)) {
26086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Subtract" "', expected argument " "1"" of type '" "wxDateTime const *""'");
26087 }
26088 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26089 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26090 if (!SWIG_IsOK(res2)) {
26091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26092 }
26093 if (!argp2) {
26094 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_Subtract" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26095 }
26096 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26097 {
26098 PyThreadState* __tstate = wxPyBeginAllowThreads();
26099 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
26100 wxPyEndAllowThreads(__tstate);
26101 if (PyErr_Occurred()) SWIG_fail;
26102 }
26103 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26104 return resultobj;
26105 fail:
26106 return NULL;
26107 }
26108
26109
26110 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26111 PyObject *resultobj = 0;
26112 wxDateTime *arg1 = (wxDateTime *) 0 ;
26113 wxTimeSpan *arg2 = 0 ;
26114 wxDateTime *result = 0 ;
26115 void *argp1 = 0 ;
26116 int res1 = 0 ;
26117 void *argp2 = 0 ;
26118 int res2 = 0 ;
26119
26120 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26122 if (!SWIG_IsOK(res1)) {
26123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26124 }
26125 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26126 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26127 if (!SWIG_IsOK(res2)) {
26128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26129 }
26130 if (!argp2) {
26131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26132 }
26133 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26134 {
26135 PyThreadState* __tstate = wxPyBeginAllowThreads();
26136 {
26137 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
26138 result = (wxDateTime *) &_result_ref;
26139 }
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26144 return resultobj;
26145 fail:
26146 return NULL;
26147 }
26148
26149
26150 SWIGINTERN PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26151 PyObject *resultobj = 0;
26152 wxDateTime *arg1 = (wxDateTime *) 0 ;
26153 wxDateSpan *arg2 = 0 ;
26154 wxDateTime *result = 0 ;
26155 void *argp1 = 0 ;
26156 int res1 = 0 ;
26157 void *argp2 = 0 ;
26158 int res2 = 0 ;
26159
26160 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26162 if (!SWIG_IsOK(res1)) {
26163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___iadd__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26164 }
26165 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26166 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26167 if (!SWIG_IsOK(res2)) {
26168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26169 }
26170 if (!argp2) {
26171 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26172 }
26173 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26174 {
26175 PyThreadState* __tstate = wxPyBeginAllowThreads();
26176 {
26177 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26178 result = (wxDateTime *) &_result_ref;
26179 }
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26184 return resultobj;
26185 fail:
26186 return NULL;
26187 }
26188
26189
26190 SWIGINTERN PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
26191 int argc;
26192 PyObject *argv[3];
26193
26194 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___iadd__",0,2,argv))) SWIG_fail;
26195 --argc;
26196 if (argc == 2) {
26197 int _v = 0;
26198 {
26199 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26200 _v = SWIG_CheckState(res);
26201 }
26202 if (!_v) goto check_1;
26203 return _wrap_DateTime___iadd____SWIG_0(self, argc, argv);
26204 }
26205 check_1:
26206
26207 if (argc == 2) {
26208 return _wrap_DateTime___iadd____SWIG_1(self, argc, argv);
26209 }
26210
26211 fail:
26212 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
26213 return NULL;
26214 }
26215
26216
26217 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26218 PyObject *resultobj = 0;
26219 wxDateTime *arg1 = (wxDateTime *) 0 ;
26220 wxTimeSpan *arg2 = 0 ;
26221 wxDateTime *result = 0 ;
26222 void *argp1 = 0 ;
26223 int res1 = 0 ;
26224 void *argp2 = 0 ;
26225 int res2 = 0 ;
26226
26227 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26229 if (!SWIG_IsOK(res1)) {
26230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26231 }
26232 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26233 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26234 if (!SWIG_IsOK(res2)) {
26235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26236 }
26237 if (!argp2) {
26238 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26239 }
26240 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26241 {
26242 PyThreadState* __tstate = wxPyBeginAllowThreads();
26243 {
26244 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
26245 result = (wxDateTime *) &_result_ref;
26246 }
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26258 PyObject *resultobj = 0;
26259 wxDateTime *arg1 = (wxDateTime *) 0 ;
26260 wxDateSpan *arg2 = 0 ;
26261 wxDateTime *result = 0 ;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 void *argp2 = 0 ;
26265 int res2 = 0 ;
26266
26267 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, SWIG_POINTER_DISOWN | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___isub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26271 }
26272 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26273 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26274 if (!SWIG_IsOK(res2)) {
26275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26276 }
26277 if (!argp2) {
26278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26279 }
26280 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26281 {
26282 PyThreadState* __tstate = wxPyBeginAllowThreads();
26283 {
26284 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26285 result = (wxDateTime *) &_result_ref;
26286 }
26287 wxPyEndAllowThreads(__tstate);
26288 if (PyErr_Occurred()) SWIG_fail;
26289 }
26290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 SWIGINTERN PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
26298 int argc;
26299 PyObject *argv[3];
26300
26301 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___isub__",0,2,argv))) SWIG_fail;
26302 --argc;
26303 if (argc == 2) {
26304 int _v = 0;
26305 {
26306 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26307 _v = SWIG_CheckState(res);
26308 }
26309 if (!_v) goto check_1;
26310 return _wrap_DateTime___isub____SWIG_0(self, argc, argv);
26311 }
26312 check_1:
26313
26314 if (argc == 2) {
26315 return _wrap_DateTime___isub____SWIG_1(self, argc, argv);
26316 }
26317
26318 fail:
26319 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
26320 return NULL;
26321 }
26322
26323
26324 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26325 PyObject *resultobj = 0;
26326 wxDateTime *arg1 = (wxDateTime *) 0 ;
26327 wxTimeSpan *arg2 = 0 ;
26328 wxDateTime result;
26329 void *argp1 = 0 ;
26330 int res1 = 0 ;
26331 void *argp2 = 0 ;
26332 int res2 = 0 ;
26333
26334 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26336 if (!SWIG_IsOK(res1)) {
26337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26338 }
26339 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26340 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26341 if (!SWIG_IsOK(res2)) {
26342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26343 }
26344 if (!argp2) {
26345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26346 }
26347 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26348 {
26349 PyThreadState* __tstate = wxPyBeginAllowThreads();
26350 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
26351 wxPyEndAllowThreads(__tstate);
26352 if (PyErr_Occurred()) SWIG_fail;
26353 }
26354 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26355 return resultobj;
26356 fail:
26357 return NULL;
26358 }
26359
26360
26361 SWIGINTERN PyObject *_wrap_DateTime___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26362 PyObject *resultobj = 0;
26363 wxDateTime *arg1 = (wxDateTime *) 0 ;
26364 wxDateSpan *arg2 = 0 ;
26365 wxDateTime result;
26366 void *argp1 = 0 ;
26367 int res1 = 0 ;
26368 void *argp2 = 0 ;
26369 int res2 = 0 ;
26370
26371 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___add__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26375 }
26376 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26377 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26378 if (!SWIG_IsOK(res2)) {
26379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26380 }
26381 if (!argp2) {
26382 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26383 }
26384 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26385 {
26386 PyThreadState* __tstate = wxPyBeginAllowThreads();
26387 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
26388 wxPyEndAllowThreads(__tstate);
26389 if (PyErr_Occurred()) SWIG_fail;
26390 }
26391 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26392 return resultobj;
26393 fail:
26394 return NULL;
26395 }
26396
26397
26398 SWIGINTERN PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
26399 int argc;
26400 PyObject *argv[3];
26401
26402 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___add__",0,2,argv))) SWIG_fail;
26403 --argc;
26404 if (argc == 2) {
26405 int _v = 0;
26406 {
26407 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26408 _v = SWIG_CheckState(res);
26409 }
26410 if (!_v) goto check_1;
26411 return _wrap_DateTime___add____SWIG_0(self, argc, argv);
26412 }
26413 check_1:
26414
26415 if (argc == 2) {
26416 return _wrap_DateTime___add____SWIG_1(self, argc, argv);
26417 }
26418
26419 fail:
26420 Py_INCREF(Py_NotImplemented);
26421 return Py_NotImplemented;
26422 }
26423
26424
26425 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26426 PyObject *resultobj = 0;
26427 wxDateTime *arg1 = (wxDateTime *) 0 ;
26428 wxDateTime *arg2 = 0 ;
26429 wxTimeSpan result;
26430 void *argp1 = 0 ;
26431 int res1 = 0 ;
26432 void *argp2 = 0 ;
26433 int res2 = 0 ;
26434
26435 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26437 if (!SWIG_IsOK(res1)) {
26438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26439 }
26440 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26441 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26442 if (!SWIG_IsOK(res2)) {
26443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26444 }
26445 if (!argp2) {
26446 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26447 }
26448 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26449 {
26450 PyThreadState* __tstate = wxPyBeginAllowThreads();
26451 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
26456 return resultobj;
26457 fail:
26458 return NULL;
26459 }
26460
26461
26462 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26463 PyObject *resultobj = 0;
26464 wxDateTime *arg1 = (wxDateTime *) 0 ;
26465 wxTimeSpan *arg2 = 0 ;
26466 wxDateTime result;
26467 void *argp1 = 0 ;
26468 int res1 = 0 ;
26469 void *argp2 = 0 ;
26470 int res2 = 0 ;
26471
26472 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26474 if (!SWIG_IsOK(res1)) {
26475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26476 }
26477 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26478 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
26479 if (!SWIG_IsOK(res2)) {
26480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26481 }
26482 if (!argp2) {
26483 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
26484 }
26485 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
26486 {
26487 PyThreadState* __tstate = wxPyBeginAllowThreads();
26488 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
26489 wxPyEndAllowThreads(__tstate);
26490 if (PyErr_Occurred()) SWIG_fail;
26491 }
26492 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26493 return resultobj;
26494 fail:
26495 return NULL;
26496 }
26497
26498
26499 SWIGINTERN PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
26500 PyObject *resultobj = 0;
26501 wxDateTime *arg1 = (wxDateTime *) 0 ;
26502 wxDateSpan *arg2 = 0 ;
26503 wxDateTime result;
26504 void *argp1 = 0 ;
26505 int res1 = 0 ;
26506 void *argp2 = 0 ;
26507 int res2 = 0 ;
26508
26509 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
26510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26511 if (!SWIG_IsOK(res1)) {
26512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___sub__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26513 }
26514 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26515 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
26516 if (!SWIG_IsOK(res2)) {
26517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26518 }
26519 if (!argp2) {
26520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
26521 }
26522 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
26523 {
26524 PyThreadState* __tstate = wxPyBeginAllowThreads();
26525 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
26526 wxPyEndAllowThreads(__tstate);
26527 if (PyErr_Occurred()) SWIG_fail;
26528 }
26529 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
26530 return resultobj;
26531 fail:
26532 return NULL;
26533 }
26534
26535
26536 SWIGINTERN PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
26537 int argc;
26538 PyObject *argv[3];
26539
26540 if (!(argc = SWIG_Python_UnpackTuple(args,"DateTime___sub__",0,2,argv))) SWIG_fail;
26541 --argc;
26542 if (argc == 2) {
26543 int _v = 0;
26544 {
26545 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDateTime, 0);
26546 _v = SWIG_CheckState(res);
26547 }
26548 if (!_v) goto check_1;
26549 return _wrap_DateTime___sub____SWIG_0(self, argc, argv);
26550 }
26551 check_1:
26552
26553 if (argc == 2) {
26554 int _v = 0;
26555 {
26556 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxTimeSpan, 0);
26557 _v = SWIG_CheckState(res);
26558 }
26559 if (!_v) goto check_2;
26560 return _wrap_DateTime___sub____SWIG_1(self, argc, argv);
26561 }
26562 check_2:
26563
26564 if (argc == 2) {
26565 return _wrap_DateTime___sub____SWIG_2(self, argc, argv);
26566 }
26567
26568 fail:
26569 Py_INCREF(Py_NotImplemented);
26570 return Py_NotImplemented;
26571 }
26572
26573
26574 SWIGINTERN PyObject *_wrap_DateTime___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26575 PyObject *resultobj = 0;
26576 wxDateTime *arg1 = (wxDateTime *) 0 ;
26577 wxDateTime *arg2 = (wxDateTime *) 0 ;
26578 bool result;
26579 void *argp1 = 0 ;
26580 int res1 = 0 ;
26581 void *argp2 = 0 ;
26582 int res2 = 0 ;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 char * kwnames[] = {
26586 (char *) "self",(char *) "other", NULL
26587 };
26588
26589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
26590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26591 if (!SWIG_IsOK(res1)) {
26592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___lt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26593 }
26594 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26596 if (!SWIG_IsOK(res2)) {
26597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___lt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26598 }
26599 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
26603 wxPyEndAllowThreads(__tstate);
26604 if (PyErr_Occurred()) SWIG_fail;
26605 }
26606 {
26607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26608 }
26609 return resultobj;
26610 fail:
26611 return NULL;
26612 }
26613
26614
26615 SWIGINTERN PyObject *_wrap_DateTime___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26616 PyObject *resultobj = 0;
26617 wxDateTime *arg1 = (wxDateTime *) 0 ;
26618 wxDateTime *arg2 = (wxDateTime *) 0 ;
26619 bool result;
26620 void *argp1 = 0 ;
26621 int res1 = 0 ;
26622 void *argp2 = 0 ;
26623 int res2 = 0 ;
26624 PyObject * obj0 = 0 ;
26625 PyObject * obj1 = 0 ;
26626 char * kwnames[] = {
26627 (char *) "self",(char *) "other", NULL
26628 };
26629
26630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) SWIG_fail;
26631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26632 if (!SWIG_IsOK(res1)) {
26633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___le__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26634 }
26635 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26636 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26637 if (!SWIG_IsOK(res2)) {
26638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___le__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26639 }
26640 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 {
26648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26649 }
26650 return resultobj;
26651 fail:
26652 return NULL;
26653 }
26654
26655
26656 SWIGINTERN PyObject *_wrap_DateTime___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26657 PyObject *resultobj = 0;
26658 wxDateTime *arg1 = (wxDateTime *) 0 ;
26659 wxDateTime *arg2 = (wxDateTime *) 0 ;
26660 bool result;
26661 void *argp1 = 0 ;
26662 int res1 = 0 ;
26663 void *argp2 = 0 ;
26664 int res2 = 0 ;
26665 PyObject * obj0 = 0 ;
26666 PyObject * obj1 = 0 ;
26667 char * kwnames[] = {
26668 (char *) "self",(char *) "other", NULL
26669 };
26670
26671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
26672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26673 if (!SWIG_IsOK(res1)) {
26674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___gt__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26675 }
26676 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26678 if (!SWIG_IsOK(res2)) {
26679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___gt__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26680 }
26681 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26682 {
26683 PyThreadState* __tstate = wxPyBeginAllowThreads();
26684 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
26685 wxPyEndAllowThreads(__tstate);
26686 if (PyErr_Occurred()) SWIG_fail;
26687 }
26688 {
26689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26690 }
26691 return resultobj;
26692 fail:
26693 return NULL;
26694 }
26695
26696
26697 SWIGINTERN PyObject *_wrap_DateTime___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26698 PyObject *resultobj = 0;
26699 wxDateTime *arg1 = (wxDateTime *) 0 ;
26700 wxDateTime *arg2 = (wxDateTime *) 0 ;
26701 bool result;
26702 void *argp1 = 0 ;
26703 int res1 = 0 ;
26704 void *argp2 = 0 ;
26705 int res2 = 0 ;
26706 PyObject * obj0 = 0 ;
26707 PyObject * obj1 = 0 ;
26708 char * kwnames[] = {
26709 (char *) "self",(char *) "other", NULL
26710 };
26711
26712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
26713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26714 if (!SWIG_IsOK(res1)) {
26715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ge__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26716 }
26717 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26719 if (!SWIG_IsOK(res2)) {
26720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ge__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26721 }
26722 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26723 {
26724 PyThreadState* __tstate = wxPyBeginAllowThreads();
26725 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
26726 wxPyEndAllowThreads(__tstate);
26727 if (PyErr_Occurred()) SWIG_fail;
26728 }
26729 {
26730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26731 }
26732 return resultobj;
26733 fail:
26734 return NULL;
26735 }
26736
26737
26738 SWIGINTERN PyObject *_wrap_DateTime___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26739 PyObject *resultobj = 0;
26740 wxDateTime *arg1 = (wxDateTime *) 0 ;
26741 wxDateTime *arg2 = (wxDateTime *) 0 ;
26742 bool result;
26743 void *argp1 = 0 ;
26744 int res1 = 0 ;
26745 void *argp2 = 0 ;
26746 int res2 = 0 ;
26747 PyObject * obj0 = 0 ;
26748 PyObject * obj1 = 0 ;
26749 char * kwnames[] = {
26750 (char *) "self",(char *) "other", NULL
26751 };
26752
26753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
26754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26755 if (!SWIG_IsOK(res1)) {
26756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___eq__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26757 }
26758 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26760 if (!SWIG_IsOK(res2)) {
26761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___eq__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26762 }
26763 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26764 {
26765 PyThreadState* __tstate = wxPyBeginAllowThreads();
26766 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
26767 wxPyEndAllowThreads(__tstate);
26768 if (PyErr_Occurred()) SWIG_fail;
26769 }
26770 {
26771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26772 }
26773 return resultobj;
26774 fail:
26775 return NULL;
26776 }
26777
26778
26779 SWIGINTERN PyObject *_wrap_DateTime___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26780 PyObject *resultobj = 0;
26781 wxDateTime *arg1 = (wxDateTime *) 0 ;
26782 wxDateTime *arg2 = (wxDateTime *) 0 ;
26783 bool result;
26784 void *argp1 = 0 ;
26785 int res1 = 0 ;
26786 void *argp2 = 0 ;
26787 int res2 = 0 ;
26788 PyObject * obj0 = 0 ;
26789 PyObject * obj1 = 0 ;
26790 char * kwnames[] = {
26791 (char *) "self",(char *) "other", NULL
26792 };
26793
26794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
26795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26796 if (!SWIG_IsOK(res1)) {
26797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime___ne__" "', expected argument " "1"" of type '" "wxDateTime *""'");
26798 }
26799 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateTime, 0 | 0 );
26801 if (!SWIG_IsOK(res2)) {
26802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateTime___ne__" "', expected argument " "2"" of type '" "wxDateTime const *""'");
26803 }
26804 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26805 {
26806 PyThreadState* __tstate = wxPyBeginAllowThreads();
26807 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
26808 wxPyEndAllowThreads(__tstate);
26809 if (PyErr_Occurred()) SWIG_fail;
26810 }
26811 {
26812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26813 }
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 SWIGINTERN PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj = 0;
26822 wxDateTime *arg1 = (wxDateTime *) 0 ;
26823 wxString *arg2 = 0 ;
26824 int result;
26825 void *argp1 = 0 ;
26826 int res1 = 0 ;
26827 bool temp2 = false ;
26828 PyObject * obj0 = 0 ;
26829 PyObject * obj1 = 0 ;
26830 char * kwnames[] = {
26831 (char *) "self",(char *) "date", NULL
26832 };
26833
26834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",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_ParseRfc822Date" "', expected argument " "1"" of type '" "wxDateTime *""'");
26838 }
26839 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26840 {
26841 arg2 = wxString_in_helper(obj1);
26842 if (arg2 == NULL) SWIG_fail;
26843 temp2 = true;
26844 }
26845 {
26846 PyThreadState* __tstate = wxPyBeginAllowThreads();
26847 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
26848 wxPyEndAllowThreads(__tstate);
26849 if (PyErr_Occurred()) SWIG_fail;
26850 }
26851 resultobj = SWIG_From_int(static_cast< int >(result));
26852 {
26853 if (temp2)
26854 delete arg2;
26855 }
26856 return resultobj;
26857 fail:
26858 {
26859 if (temp2)
26860 delete arg2;
26861 }
26862 return NULL;
26863 }
26864
26865
26866 SWIGINTERN PyObject *_wrap_DateTime_ParseFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26867 PyObject *resultobj = 0;
26868 wxDateTime *arg1 = (wxDateTime *) 0 ;
26869 wxString *arg2 = 0 ;
26870 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
26871 wxString *arg3 = (wxString *) &arg3_defvalue ;
26872 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
26873 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
26874 int result;
26875 void *argp1 = 0 ;
26876 int res1 = 0 ;
26877 bool temp2 = false ;
26878 bool temp3 = false ;
26879 void *argp4 = 0 ;
26880 int res4 = 0 ;
26881 PyObject * obj0 = 0 ;
26882 PyObject * obj1 = 0 ;
26883 PyObject * obj2 = 0 ;
26884 PyObject * obj3 = 0 ;
26885 char * kwnames[] = {
26886 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
26887 };
26888
26889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26891 if (!SWIG_IsOK(res1)) {
26892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseFormat" "', expected argument " "1"" of type '" "wxDateTime *""'");
26893 }
26894 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26895 {
26896 arg2 = wxString_in_helper(obj1);
26897 if (arg2 == NULL) SWIG_fail;
26898 temp2 = true;
26899 }
26900 if (obj2) {
26901 {
26902 arg3 = wxString_in_helper(obj2);
26903 if (arg3 == NULL) SWIG_fail;
26904 temp3 = true;
26905 }
26906 }
26907 if (obj3) {
26908 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDateTime, 0 | 0);
26909 if (!SWIG_IsOK(res4)) {
26910 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26911 }
26912 if (!argp4) {
26913 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateTime_ParseFormat" "', expected argument " "4"" of type '" "wxDateTime const &""'");
26914 }
26915 arg4 = reinterpret_cast< wxDateTime * >(argp4);
26916 }
26917 {
26918 PyThreadState* __tstate = wxPyBeginAllowThreads();
26919 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
26920 wxPyEndAllowThreads(__tstate);
26921 if (PyErr_Occurred()) SWIG_fail;
26922 }
26923 resultobj = SWIG_From_int(static_cast< int >(result));
26924 {
26925 if (temp2)
26926 delete arg2;
26927 }
26928 {
26929 if (temp3)
26930 delete arg3;
26931 }
26932 return resultobj;
26933 fail:
26934 {
26935 if (temp2)
26936 delete arg2;
26937 }
26938 {
26939 if (temp3)
26940 delete arg3;
26941 }
26942 return NULL;
26943 }
26944
26945
26946 SWIGINTERN PyObject *_wrap_DateTime_ParseDateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26947 PyObject *resultobj = 0;
26948 wxDateTime *arg1 = (wxDateTime *) 0 ;
26949 wxString *arg2 = 0 ;
26950 int result;
26951 void *argp1 = 0 ;
26952 int res1 = 0 ;
26953 bool temp2 = false ;
26954 PyObject * obj0 = 0 ;
26955 PyObject * obj1 = 0 ;
26956 char * kwnames[] = {
26957 (char *) "self",(char *) "datetime", NULL
26958 };
26959
26960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) SWIG_fail;
26961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
26962 if (!SWIG_IsOK(res1)) {
26963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDateTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
26964 }
26965 arg1 = reinterpret_cast< wxDateTime * >(argp1);
26966 {
26967 arg2 = wxString_in_helper(obj1);
26968 if (arg2 == NULL) SWIG_fail;
26969 temp2 = true;
26970 }
26971 {
26972 PyThreadState* __tstate = wxPyBeginAllowThreads();
26973 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
26974 wxPyEndAllowThreads(__tstate);
26975 if (PyErr_Occurred()) SWIG_fail;
26976 }
26977 resultobj = SWIG_From_int(static_cast< int >(result));
26978 {
26979 if (temp2)
26980 delete arg2;
26981 }
26982 return resultobj;
26983 fail:
26984 {
26985 if (temp2)
26986 delete arg2;
26987 }
26988 return NULL;
26989 }
26990
26991
26992 SWIGINTERN PyObject *_wrap_DateTime_ParseDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj = 0;
26994 wxDateTime *arg1 = (wxDateTime *) 0 ;
26995 wxString *arg2 = 0 ;
26996 int result;
26997 void *argp1 = 0 ;
26998 int res1 = 0 ;
26999 bool temp2 = false ;
27000 PyObject * obj0 = 0 ;
27001 PyObject * obj1 = 0 ;
27002 char * kwnames[] = {
27003 (char *) "self",(char *) "date", NULL
27004 };
27005
27006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) SWIG_fail;
27007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27008 if (!SWIG_IsOK(res1)) {
27009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseDate" "', expected argument " "1"" of type '" "wxDateTime *""'");
27010 }
27011 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27012 {
27013 arg2 = wxString_in_helper(obj1);
27014 if (arg2 == NULL) SWIG_fail;
27015 temp2 = true;
27016 }
27017 {
27018 PyThreadState* __tstate = wxPyBeginAllowThreads();
27019 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 resultobj = SWIG_From_int(static_cast< int >(result));
27024 {
27025 if (temp2)
27026 delete arg2;
27027 }
27028 return resultobj;
27029 fail:
27030 {
27031 if (temp2)
27032 delete arg2;
27033 }
27034 return NULL;
27035 }
27036
27037
27038 SWIGINTERN PyObject *_wrap_DateTime_ParseTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27039 PyObject *resultobj = 0;
27040 wxDateTime *arg1 = (wxDateTime *) 0 ;
27041 wxString *arg2 = 0 ;
27042 int result;
27043 void *argp1 = 0 ;
27044 int res1 = 0 ;
27045 bool temp2 = false ;
27046 PyObject * obj0 = 0 ;
27047 PyObject * obj1 = 0 ;
27048 char * kwnames[] = {
27049 (char *) "self",(char *) "time", NULL
27050 };
27051
27052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) SWIG_fail;
27053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27054 if (!SWIG_IsOK(res1)) {
27055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_ParseTime" "', expected argument " "1"" of type '" "wxDateTime *""'");
27056 }
27057 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27058 {
27059 arg2 = wxString_in_helper(obj1);
27060 if (arg2 == NULL) SWIG_fail;
27061 temp2 = true;
27062 }
27063 {
27064 PyThreadState* __tstate = wxPyBeginAllowThreads();
27065 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
27066 wxPyEndAllowThreads(__tstate);
27067 if (PyErr_Occurred()) SWIG_fail;
27068 }
27069 resultobj = SWIG_From_int(static_cast< int >(result));
27070 {
27071 if (temp2)
27072 delete arg2;
27073 }
27074 return resultobj;
27075 fail:
27076 {
27077 if (temp2)
27078 delete arg2;
27079 }
27080 return NULL;
27081 }
27082
27083
27084 SWIGINTERN PyObject *_wrap_DateTime_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27085 PyObject *resultobj = 0;
27086 wxDateTime *arg1 = (wxDateTime *) 0 ;
27087 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
27088 wxString *arg2 = (wxString *) &arg2_defvalue ;
27089 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
27090 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
27091 wxString result;
27092 void *argp1 = 0 ;
27093 int res1 = 0 ;
27094 bool temp2 = false ;
27095 bool temp3 = false ;
27096 PyObject * obj0 = 0 ;
27097 PyObject * obj1 = 0 ;
27098 PyObject * obj2 = 0 ;
27099 char * kwnames[] = {
27100 (char *) "self",(char *) "format",(char *) "tz", NULL
27101 };
27102
27103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27105 if (!SWIG_IsOK(res1)) {
27106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_Format" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27107 }
27108 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27109 if (obj1) {
27110 {
27111 arg2 = wxString_in_helper(obj1);
27112 if (arg2 == NULL) SWIG_fail;
27113 temp2 = true;
27114 }
27115 }
27116 if (obj2) {
27117 {
27118 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
27119 temp3 = true;
27120 }
27121 }
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 {
27129 #if wxUSE_UNICODE
27130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27131 #else
27132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27133 #endif
27134 }
27135 {
27136 if (temp2)
27137 delete arg2;
27138 }
27139 {
27140 if (temp3) delete arg3;
27141 }
27142 return resultobj;
27143 fail:
27144 {
27145 if (temp2)
27146 delete arg2;
27147 }
27148 {
27149 if (temp3) delete arg3;
27150 }
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *_wrap_DateTime_FormatDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27156 PyObject *resultobj = 0;
27157 wxDateTime *arg1 = (wxDateTime *) 0 ;
27158 wxString result;
27159 void *argp1 = 0 ;
27160 int res1 = 0 ;
27161 PyObject *swig_obj[1] ;
27162
27163 if (!args) SWIG_fail;
27164 swig_obj[0] = args;
27165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27166 if (!SWIG_IsOK(res1)) {
27167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatDate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27168 }
27169 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 result = ((wxDateTime const *)arg1)->FormatDate();
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 {
27177 #if wxUSE_UNICODE
27178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27179 #else
27180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27181 #endif
27182 }
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 SWIGINTERN PyObject *_wrap_DateTime_FormatTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27190 PyObject *resultobj = 0;
27191 wxDateTime *arg1 = (wxDateTime *) 0 ;
27192 wxString result;
27193 void *argp1 = 0 ;
27194 int res1 = 0 ;
27195 PyObject *swig_obj[1] ;
27196
27197 if (!args) SWIG_fail;
27198 swig_obj[0] = args;
27199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27200 if (!SWIG_IsOK(res1)) {
27201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27202 }
27203 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27204 {
27205 PyThreadState* __tstate = wxPyBeginAllowThreads();
27206 result = ((wxDateTime const *)arg1)->FormatTime();
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 {
27211 #if wxUSE_UNICODE
27212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27213 #else
27214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27215 #endif
27216 }
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_DateTime_FormatISODate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 PyObject *resultobj = 0;
27225 wxDateTime *arg1 = (wxDateTime *) 0 ;
27226 wxString result;
27227 void *argp1 = 0 ;
27228 int res1 = 0 ;
27229 PyObject *swig_obj[1] ;
27230
27231 if (!args) SWIG_fail;
27232 swig_obj[0] = args;
27233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27234 if (!SWIG_IsOK(res1)) {
27235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISODate" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27236 }
27237 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27238 {
27239 PyThreadState* __tstate = wxPyBeginAllowThreads();
27240 result = ((wxDateTime const *)arg1)->FormatISODate();
27241 wxPyEndAllowThreads(__tstate);
27242 if (PyErr_Occurred()) SWIG_fail;
27243 }
27244 {
27245 #if wxUSE_UNICODE
27246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27247 #else
27248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27249 #endif
27250 }
27251 return resultobj;
27252 fail:
27253 return NULL;
27254 }
27255
27256
27257 SWIGINTERN PyObject *_wrap_DateTime_FormatISOTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27258 PyObject *resultobj = 0;
27259 wxDateTime *arg1 = (wxDateTime *) 0 ;
27260 wxString result;
27261 void *argp1 = 0 ;
27262 int res1 = 0 ;
27263 PyObject *swig_obj[1] ;
27264
27265 if (!args) SWIG_fail;
27266 swig_obj[0] = args;
27267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateTime, 0 | 0 );
27268 if (!SWIG_IsOK(res1)) {
27269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateTime_FormatISOTime" "', expected argument " "1"" of type '" "wxDateTime const *""'");
27270 }
27271 arg1 = reinterpret_cast< wxDateTime * >(argp1);
27272 {
27273 PyThreadState* __tstate = wxPyBeginAllowThreads();
27274 result = ((wxDateTime const *)arg1)->FormatISOTime();
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 {
27279 #if wxUSE_UNICODE
27280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27281 #else
27282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27283 #endif
27284 }
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 SWIGINTERN PyObject *DateTime_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27292 PyObject *obj;
27293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27294 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateTime, SWIG_NewClientData(obj));
27295 return SWIG_Py_Void();
27296 }
27297
27298 SWIGINTERN PyObject *DateTime_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27299 return SWIG_Python_InitShadowInstance(args);
27300 }
27301
27302 SWIGINTERN PyObject *_wrap_TimeSpan_Seconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27303 PyObject *resultobj = 0;
27304 long arg1 ;
27305 wxTimeSpan result;
27306 long val1 ;
27307 int ecode1 = 0 ;
27308 PyObject * obj0 = 0 ;
27309 char * kwnames[] = {
27310 (char *) "sec", NULL
27311 };
27312
27313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) SWIG_fail;
27314 ecode1 = SWIG_AsVal_long(obj0, &val1);
27315 if (!SWIG_IsOK(ecode1)) {
27316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Seconds" "', expected argument " "1"" of type '" "long""'");
27317 }
27318 arg1 = static_cast< long >(val1);
27319 {
27320 PyThreadState* __tstate = wxPyBeginAllowThreads();
27321 result = wxTimeSpan::Seconds(arg1);
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27326 return resultobj;
27327 fail:
27328 return NULL;
27329 }
27330
27331
27332 SWIGINTERN PyObject *_wrap_TimeSpan_Second(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27333 PyObject *resultobj = 0;
27334 wxTimeSpan result;
27335
27336 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Second",0,0,0)) SWIG_fail;
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 result = wxTimeSpan::Second();
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_TimeSpan_Minutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27351 PyObject *resultobj = 0;
27352 long arg1 ;
27353 wxTimeSpan result;
27354 long val1 ;
27355 int ecode1 = 0 ;
27356 PyObject * obj0 = 0 ;
27357 char * kwnames[] = {
27358 (char *) "min", NULL
27359 };
27360
27361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) SWIG_fail;
27362 ecode1 = SWIG_AsVal_long(obj0, &val1);
27363 if (!SWIG_IsOK(ecode1)) {
27364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Minutes" "', expected argument " "1"" of type '" "long""'");
27365 }
27366 arg1 = static_cast< long >(val1);
27367 {
27368 PyThreadState* __tstate = wxPyBeginAllowThreads();
27369 result = wxTimeSpan::Minutes(arg1);
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 SWIGINTERN PyObject *_wrap_TimeSpan_Minute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27381 PyObject *resultobj = 0;
27382 wxTimeSpan result;
27383
27384 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Minute",0,0,0)) SWIG_fail;
27385 {
27386 PyThreadState* __tstate = wxPyBeginAllowThreads();
27387 result = wxTimeSpan::Minute();
27388 wxPyEndAllowThreads(__tstate);
27389 if (PyErr_Occurred()) SWIG_fail;
27390 }
27391 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27392 return resultobj;
27393 fail:
27394 return NULL;
27395 }
27396
27397
27398 SWIGINTERN PyObject *_wrap_TimeSpan_Hours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27399 PyObject *resultobj = 0;
27400 long arg1 ;
27401 wxTimeSpan result;
27402 long val1 ;
27403 int ecode1 = 0 ;
27404 PyObject * obj0 = 0 ;
27405 char * kwnames[] = {
27406 (char *) "hours", NULL
27407 };
27408
27409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) SWIG_fail;
27410 ecode1 = SWIG_AsVal_long(obj0, &val1);
27411 if (!SWIG_IsOK(ecode1)) {
27412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Hours" "', expected argument " "1"" of type '" "long""'");
27413 }
27414 arg1 = static_cast< long >(val1);
27415 {
27416 PyThreadState* __tstate = wxPyBeginAllowThreads();
27417 result = wxTimeSpan::Hours(arg1);
27418 wxPyEndAllowThreads(__tstate);
27419 if (PyErr_Occurred()) SWIG_fail;
27420 }
27421 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27422 return resultobj;
27423 fail:
27424 return NULL;
27425 }
27426
27427
27428 SWIGINTERN PyObject *_wrap_TimeSpan_Hour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27429 PyObject *resultobj = 0;
27430 wxTimeSpan result;
27431
27432 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Hour",0,0,0)) SWIG_fail;
27433 {
27434 PyThreadState* __tstate = wxPyBeginAllowThreads();
27435 result = wxTimeSpan::Hour();
27436 wxPyEndAllowThreads(__tstate);
27437 if (PyErr_Occurred()) SWIG_fail;
27438 }
27439 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 SWIGINTERN PyObject *_wrap_TimeSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj = 0;
27448 long arg1 ;
27449 wxTimeSpan result;
27450 long val1 ;
27451 int ecode1 = 0 ;
27452 PyObject * obj0 = 0 ;
27453 char * kwnames[] = {
27454 (char *) "days", NULL
27455 };
27456
27457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) SWIG_fail;
27458 ecode1 = SWIG_AsVal_long(obj0, &val1);
27459 if (!SWIG_IsOK(ecode1)) {
27460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Days" "', expected argument " "1"" of type '" "long""'");
27461 }
27462 arg1 = static_cast< long >(val1);
27463 {
27464 PyThreadState* __tstate = wxPyBeginAllowThreads();
27465 result = wxTimeSpan::Days(arg1);
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 SWIGINTERN PyObject *_wrap_TimeSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27477 PyObject *resultobj = 0;
27478 wxTimeSpan result;
27479
27480 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Day",0,0,0)) SWIG_fail;
27481 {
27482 PyThreadState* __tstate = wxPyBeginAllowThreads();
27483 result = wxTimeSpan::Day();
27484 wxPyEndAllowThreads(__tstate);
27485 if (PyErr_Occurred()) SWIG_fail;
27486 }
27487 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27488 return resultobj;
27489 fail:
27490 return NULL;
27491 }
27492
27493
27494 SWIGINTERN PyObject *_wrap_TimeSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27495 PyObject *resultobj = 0;
27496 long arg1 ;
27497 wxTimeSpan result;
27498 long val1 ;
27499 int ecode1 = 0 ;
27500 PyObject * obj0 = 0 ;
27501 char * kwnames[] = {
27502 (char *) "days", NULL
27503 };
27504
27505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) SWIG_fail;
27506 ecode1 = SWIG_AsVal_long(obj0, &val1);
27507 if (!SWIG_IsOK(ecode1)) {
27508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "TimeSpan_Weeks" "', expected argument " "1"" of type '" "long""'");
27509 }
27510 arg1 = static_cast< long >(val1);
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 result = wxTimeSpan::Weeks(arg1);
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 SWIGINTERN PyObject *_wrap_TimeSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27525 PyObject *resultobj = 0;
27526 wxTimeSpan result;
27527
27528 if (!SWIG_Python_UnpackTuple(args,"TimeSpan_Week",0,0,0)) SWIG_fail;
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = wxTimeSpan::Week();
27532 wxPyEndAllowThreads(__tstate);
27533 if (PyErr_Occurred()) SWIG_fail;
27534 }
27535 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 SWIGINTERN PyObject *_wrap_new_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27543 PyObject *resultobj = 0;
27544 long arg1 = (long) 0 ;
27545 long arg2 = (long) 0 ;
27546 long arg3 = (long) 0 ;
27547 long arg4 = (long) 0 ;
27548 wxTimeSpan *result = 0 ;
27549 long val1 ;
27550 int ecode1 = 0 ;
27551 long val2 ;
27552 int ecode2 = 0 ;
27553 long val3 ;
27554 int ecode3 = 0 ;
27555 long val4 ;
27556 int ecode4 = 0 ;
27557 PyObject * obj0 = 0 ;
27558 PyObject * obj1 = 0 ;
27559 PyObject * obj2 = 0 ;
27560 PyObject * obj3 = 0 ;
27561 char * kwnames[] = {
27562 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
27563 };
27564
27565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27566 if (obj0) {
27567 ecode1 = SWIG_AsVal_long(obj0, &val1);
27568 if (!SWIG_IsOK(ecode1)) {
27569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_TimeSpan" "', expected argument " "1"" of type '" "long""'");
27570 }
27571 arg1 = static_cast< long >(val1);
27572 }
27573 if (obj1) {
27574 ecode2 = SWIG_AsVal_long(obj1, &val2);
27575 if (!SWIG_IsOK(ecode2)) {
27576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_TimeSpan" "', expected argument " "2"" of type '" "long""'");
27577 }
27578 arg2 = static_cast< long >(val2);
27579 }
27580 if (obj2) {
27581 ecode3 = SWIG_AsVal_long(obj2, &val3);
27582 if (!SWIG_IsOK(ecode3)) {
27583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeSpan" "', expected argument " "3"" of type '" "long""'");
27584 }
27585 arg3 = static_cast< long >(val3);
27586 }
27587 if (obj3) {
27588 ecode4 = SWIG_AsVal_long(obj3, &val4);
27589 if (!SWIG_IsOK(ecode4)) {
27590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeSpan" "', expected argument " "4"" of type '" "long""'");
27591 }
27592 arg4 = static_cast< long >(val4);
27593 }
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
27597 wxPyEndAllowThreads(__tstate);
27598 if (PyErr_Occurred()) SWIG_fail;
27599 }
27600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_NEW | 0 );
27601 return resultobj;
27602 fail:
27603 return NULL;
27604 }
27605
27606
27607 SWIGINTERN PyObject *_wrap_delete_TimeSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27608 PyObject *resultobj = 0;
27609 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27610 void *argp1 = 0 ;
27611 int res1 = 0 ;
27612 PyObject *swig_obj[1] ;
27613
27614 if (!args) SWIG_fail;
27615 swig_obj[0] = args;
27616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27617 if (!SWIG_IsOK(res1)) {
27618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeSpan" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27619 }
27620 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27621 {
27622 PyThreadState* __tstate = wxPyBeginAllowThreads();
27623 delete arg1;
27624
27625 wxPyEndAllowThreads(__tstate);
27626 if (PyErr_Occurred()) SWIG_fail;
27627 }
27628 resultobj = SWIG_Py_Void();
27629 return resultobj;
27630 fail:
27631 return NULL;
27632 }
27633
27634
27635 SWIGINTERN PyObject *_wrap_TimeSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27636 PyObject *resultobj = 0;
27637 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27638 wxTimeSpan *arg2 = 0 ;
27639 wxTimeSpan *result = 0 ;
27640 void *argp1 = 0 ;
27641 int res1 = 0 ;
27642 void *argp2 = 0 ;
27643 int res2 = 0 ;
27644 PyObject * obj0 = 0 ;
27645 PyObject * obj1 = 0 ;
27646 char * kwnames[] = {
27647 (char *) "self",(char *) "diff", NULL
27648 };
27649
27650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
27651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27652 if (!SWIG_IsOK(res1)) {
27653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Add" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27654 }
27655 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27657 if (!SWIG_IsOK(res2)) {
27658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27659 }
27660 if (!argp2) {
27661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Add" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27662 }
27663 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27664 {
27665 PyThreadState* __tstate = wxPyBeginAllowThreads();
27666 {
27667 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
27668 result = (wxTimeSpan *) &_result_ref;
27669 }
27670 wxPyEndAllowThreads(__tstate);
27671 if (PyErr_Occurred()) SWIG_fail;
27672 }
27673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27674 return resultobj;
27675 fail:
27676 return NULL;
27677 }
27678
27679
27680 SWIGINTERN PyObject *_wrap_TimeSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27681 PyObject *resultobj = 0;
27682 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27683 wxTimeSpan *arg2 = 0 ;
27684 wxTimeSpan *result = 0 ;
27685 void *argp1 = 0 ;
27686 int res1 = 0 ;
27687 void *argp2 = 0 ;
27688 int res2 = 0 ;
27689 PyObject * obj0 = 0 ;
27690 PyObject * obj1 = 0 ;
27691 char * kwnames[] = {
27692 (char *) "self",(char *) "diff", NULL
27693 };
27694
27695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
27696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27697 if (!SWIG_IsOK(res1)) {
27698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Subtract" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27699 }
27700 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27701 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27702 if (!SWIG_IsOK(res2)) {
27703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27704 }
27705 if (!argp2) {
27706 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_Subtract" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27707 }
27708 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 {
27712 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
27713 result = (wxTimeSpan *) &_result_ref;
27714 }
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 SWIGINTERN PyObject *_wrap_TimeSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj = 0;
27727 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27728 int arg2 ;
27729 wxTimeSpan *result = 0 ;
27730 void *argp1 = 0 ;
27731 int res1 = 0 ;
27732 int val2 ;
27733 int ecode2 = 0 ;
27734 PyObject * obj0 = 0 ;
27735 PyObject * obj1 = 0 ;
27736 char * kwnames[] = {
27737 (char *) "self",(char *) "n", NULL
27738 };
27739
27740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
27741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27742 if (!SWIG_IsOK(res1)) {
27743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Multiply" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27744 }
27745 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27746 ecode2 = SWIG_AsVal_int(obj1, &val2);
27747 if (!SWIG_IsOK(ecode2)) {
27748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
27749 }
27750 arg2 = static_cast< int >(val2);
27751 {
27752 PyThreadState* __tstate = wxPyBeginAllowThreads();
27753 {
27754 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
27755 result = (wxTimeSpan *) &_result_ref;
27756 }
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_TimeSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27768 PyObject *resultobj = 0;
27769 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27770 wxTimeSpan *result = 0 ;
27771 void *argp1 = 0 ;
27772 int res1 = 0 ;
27773 PyObject *swig_obj[1] ;
27774
27775 if (!args) SWIG_fail;
27776 swig_obj[0] = args;
27777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27778 if (!SWIG_IsOK(res1)) {
27779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Neg" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27780 }
27781 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 {
27785 wxTimeSpan &_result_ref = (arg1)->Neg();
27786 result = (wxTimeSpan *) &_result_ref;
27787 }
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27792 return resultobj;
27793 fail:
27794 return NULL;
27795 }
27796
27797
27798 SWIGINTERN PyObject *_wrap_TimeSpan_Abs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27799 PyObject *resultobj = 0;
27800 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27801 wxTimeSpan result;
27802 void *argp1 = 0 ;
27803 int res1 = 0 ;
27804 PyObject *swig_obj[1] ;
27805
27806 if (!args) SWIG_fail;
27807 swig_obj[0] = args;
27808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27809 if (!SWIG_IsOK(res1)) {
27810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Abs" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
27811 }
27812 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27813 {
27814 PyThreadState* __tstate = wxPyBeginAllowThreads();
27815 result = ((wxTimeSpan const *)arg1)->Abs();
27816 wxPyEndAllowThreads(__tstate);
27817 if (PyErr_Occurred()) SWIG_fail;
27818 }
27819 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27820 return resultobj;
27821 fail:
27822 return NULL;
27823 }
27824
27825
27826 SWIGINTERN PyObject *_wrap_TimeSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27827 PyObject *resultobj = 0;
27828 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27829 wxTimeSpan *arg2 = 0 ;
27830 wxTimeSpan *result = 0 ;
27831 void *argp1 = 0 ;
27832 int res1 = 0 ;
27833 void *argp2 = 0 ;
27834 int res2 = 0 ;
27835 PyObject * obj0 = 0 ;
27836 PyObject * obj1 = 0 ;
27837 char * kwnames[] = {
27838 (char *) "self",(char *) "diff", NULL
27839 };
27840
27841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
27842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27843 if (!SWIG_IsOK(res1)) {
27844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___iadd__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27845 }
27846 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27847 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27848 if (!SWIG_IsOK(res2)) {
27849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27850 }
27851 if (!argp2) {
27852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___iadd__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27853 }
27854 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27855 {
27856 PyThreadState* __tstate = wxPyBeginAllowThreads();
27857 {
27858 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
27859 result = (wxTimeSpan *) &_result_ref;
27860 }
27861 wxPyEndAllowThreads(__tstate);
27862 if (PyErr_Occurred()) SWIG_fail;
27863 }
27864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 SWIGINTERN PyObject *_wrap_TimeSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27872 PyObject *resultobj = 0;
27873 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27874 wxTimeSpan *arg2 = 0 ;
27875 wxTimeSpan *result = 0 ;
27876 void *argp1 = 0 ;
27877 int res1 = 0 ;
27878 void *argp2 = 0 ;
27879 int res2 = 0 ;
27880 PyObject * obj0 = 0 ;
27881 PyObject * obj1 = 0 ;
27882 char * kwnames[] = {
27883 (char *) "self",(char *) "diff", NULL
27884 };
27885
27886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
27887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27888 if (!SWIG_IsOK(res1)) {
27889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___isub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27890 }
27891 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27892 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
27893 if (!SWIG_IsOK(res2)) {
27894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27895 }
27896 if (!argp2) {
27897 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___isub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
27898 }
27899 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 {
27903 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
27904 result = (wxTimeSpan *) &_result_ref;
27905 }
27906 wxPyEndAllowThreads(__tstate);
27907 if (PyErr_Occurred()) SWIG_fail;
27908 }
27909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 SWIGINTERN PyObject *_wrap_TimeSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj = 0;
27918 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27919 int arg2 ;
27920 wxTimeSpan *result = 0 ;
27921 void *argp1 = 0 ;
27922 int res1 = 0 ;
27923 int val2 ;
27924 int ecode2 = 0 ;
27925 PyObject * obj0 = 0 ;
27926 PyObject * obj1 = 0 ;
27927 char * kwnames[] = {
27928 (char *) "self",(char *) "n", NULL
27929 };
27930
27931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
27932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_DISOWN | 0 );
27933 if (!SWIG_IsOK(res1)) {
27934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___imul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27935 }
27936 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27937 ecode2 = SWIG_AsVal_int(obj1, &val2);
27938 if (!SWIG_IsOK(ecode2)) {
27939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___imul__" "', expected argument " "2"" of type '" "int""'");
27940 }
27941 arg2 = static_cast< int >(val2);
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 {
27945 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
27946 result = (wxTimeSpan *) &_result_ref;
27947 }
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 SWIGINTERN PyObject *_wrap_TimeSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27959 PyObject *resultobj = 0;
27960 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27961 wxTimeSpan *result = 0 ;
27962 void *argp1 = 0 ;
27963 int res1 = 0 ;
27964 PyObject *swig_obj[1] ;
27965
27966 if (!args) SWIG_fail;
27967 swig_obj[0] = args;
27968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27969 if (!SWIG_IsOK(res1)) {
27970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___neg__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
27971 }
27972 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 {
27976 wxTimeSpan &_result_ref = (arg1)->operator -();
27977 result = (wxTimeSpan *) &_result_ref;
27978 }
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTimeSpan, 0 | 0 );
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 SWIGINTERN PyObject *_wrap_TimeSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj = 0;
27991 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
27992 wxTimeSpan *arg2 = 0 ;
27993 wxTimeSpan result;
27994 void *argp1 = 0 ;
27995 int res1 = 0 ;
27996 void *argp2 = 0 ;
27997 int res2 = 0 ;
27998 PyObject * obj0 = 0 ;
27999 PyObject * obj1 = 0 ;
28000 char * kwnames[] = {
28001 (char *) "self",(char *) "other", NULL
28002 };
28003
28004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
28005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28006 if (!SWIG_IsOK(res1)) {
28007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___add__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28008 }
28009 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28010 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28011 if (!SWIG_IsOK(res2)) {
28012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28013 }
28014 if (!argp2) {
28015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___add__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28016 }
28017 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28018 {
28019 PyThreadState* __tstate = wxPyBeginAllowThreads();
28020 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_TimeSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28032 PyObject *resultobj = 0;
28033 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28034 wxTimeSpan *arg2 = 0 ;
28035 wxTimeSpan result;
28036 void *argp1 = 0 ;
28037 int res1 = 0 ;
28038 void *argp2 = 0 ;
28039 int res2 = 0 ;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 char * kwnames[] = {
28043 (char *) "self",(char *) "other", NULL
28044 };
28045
28046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
28047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28048 if (!SWIG_IsOK(res1)) {
28049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___sub__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28050 }
28051 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28053 if (!SWIG_IsOK(res2)) {
28054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28055 }
28056 if (!argp2) {
28057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan___sub__" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28058 }
28059 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28060 {
28061 PyThreadState* __tstate = wxPyBeginAllowThreads();
28062 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28067 return resultobj;
28068 fail:
28069 return NULL;
28070 }
28071
28072
28073 SWIGINTERN PyObject *_wrap_TimeSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28074 PyObject *resultobj = 0;
28075 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28076 int arg2 ;
28077 wxTimeSpan result;
28078 void *argp1 = 0 ;
28079 int res1 = 0 ;
28080 int val2 ;
28081 int ecode2 = 0 ;
28082 PyObject * obj0 = 0 ;
28083 PyObject * obj1 = 0 ;
28084 char * kwnames[] = {
28085 (char *) "self",(char *) "n", NULL
28086 };
28087
28088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
28089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28090 if (!SWIG_IsOK(res1)) {
28091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___mul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28092 }
28093 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28094 ecode2 = SWIG_AsVal_int(obj1, &val2);
28095 if (!SWIG_IsOK(ecode2)) {
28096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___mul__" "', expected argument " "2"" of type '" "int""'");
28097 }
28098 arg2 = static_cast< int >(val2);
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = wxTimeSpan___mul__(arg1,arg2);
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_TimeSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj = 0;
28114 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28115 int arg2 ;
28116 wxTimeSpan result;
28117 void *argp1 = 0 ;
28118 int res1 = 0 ;
28119 int val2 ;
28120 int ecode2 = 0 ;
28121 PyObject * obj0 = 0 ;
28122 PyObject * obj1 = 0 ;
28123 char * kwnames[] = {
28124 (char *) "self",(char *) "n", NULL
28125 };
28126
28127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
28128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28129 if (!SWIG_IsOK(res1)) {
28130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___rmul__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28131 }
28132 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28133 ecode2 = SWIG_AsVal_int(obj1, &val2);
28134 if (!SWIG_IsOK(ecode2)) {
28135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
28136 }
28137 arg2 = static_cast< int >(val2);
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 result = wxTimeSpan___rmul__(arg1,arg2);
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 resultobj = SWIG_NewPointerObj((new wxTimeSpan(static_cast< const wxTimeSpan& >(result))), SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_OWN | 0 );
28145 return resultobj;
28146 fail:
28147 return NULL;
28148 }
28149
28150
28151 SWIGINTERN PyObject *_wrap_TimeSpan___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28152 PyObject *resultobj = 0;
28153 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28154 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28155 bool result;
28156 void *argp1 = 0 ;
28157 int res1 = 0 ;
28158 void *argp2 = 0 ;
28159 int res2 = 0 ;
28160 PyObject * obj0 = 0 ;
28161 PyObject * obj1 = 0 ;
28162 char * kwnames[] = {
28163 (char *) "self",(char *) "other", NULL
28164 };
28165
28166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) SWIG_fail;
28167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28168 if (!SWIG_IsOK(res1)) {
28169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___lt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28170 }
28171 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28173 if (!SWIG_IsOK(res2)) {
28174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___lt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28175 }
28176 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 {
28184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28185 }
28186 return resultobj;
28187 fail:
28188 return NULL;
28189 }
28190
28191
28192 SWIGINTERN PyObject *_wrap_TimeSpan___le__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28193 PyObject *resultobj = 0;
28194 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28195 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28196 bool result;
28197 void *argp1 = 0 ;
28198 int res1 = 0 ;
28199 void *argp2 = 0 ;
28200 int res2 = 0 ;
28201 PyObject * obj0 = 0 ;
28202 PyObject * obj1 = 0 ;
28203 char * kwnames[] = {
28204 (char *) "self",(char *) "other", NULL
28205 };
28206
28207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) SWIG_fail;
28208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28209 if (!SWIG_IsOK(res1)) {
28210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___le__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28211 }
28212 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28214 if (!SWIG_IsOK(res2)) {
28215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___le__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28216 }
28217 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 {
28225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28226 }
28227 return resultobj;
28228 fail:
28229 return NULL;
28230 }
28231
28232
28233 SWIGINTERN PyObject *_wrap_TimeSpan___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28234 PyObject *resultobj = 0;
28235 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28236 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28237 bool result;
28238 void *argp1 = 0 ;
28239 int res1 = 0 ;
28240 void *argp2 = 0 ;
28241 int res2 = 0 ;
28242 PyObject * obj0 = 0 ;
28243 PyObject * obj1 = 0 ;
28244 char * kwnames[] = {
28245 (char *) "self",(char *) "other", NULL
28246 };
28247
28248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) SWIG_fail;
28249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28250 if (!SWIG_IsOK(res1)) {
28251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___gt__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28252 }
28253 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28255 if (!SWIG_IsOK(res2)) {
28256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___gt__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28257 }
28258 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 {
28266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28267 }
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 SWIGINTERN PyObject *_wrap_TimeSpan___ge__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj = 0;
28276 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28277 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28278 bool result;
28279 void *argp1 = 0 ;
28280 int res1 = 0 ;
28281 void *argp2 = 0 ;
28282 int res2 = 0 ;
28283 PyObject * obj0 = 0 ;
28284 PyObject * obj1 = 0 ;
28285 char * kwnames[] = {
28286 (char *) "self",(char *) "other", NULL
28287 };
28288
28289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) SWIG_fail;
28290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28291 if (!SWIG_IsOK(res1)) {
28292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ge__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28293 }
28294 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28296 if (!SWIG_IsOK(res2)) {
28297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ge__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28298 }
28299 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28300 {
28301 PyThreadState* __tstate = wxPyBeginAllowThreads();
28302 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
28303 wxPyEndAllowThreads(__tstate);
28304 if (PyErr_Occurred()) SWIG_fail;
28305 }
28306 {
28307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28308 }
28309 return resultobj;
28310 fail:
28311 return NULL;
28312 }
28313
28314
28315 SWIGINTERN PyObject *_wrap_TimeSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28316 PyObject *resultobj = 0;
28317 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28318 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28319 bool result;
28320 void *argp1 = 0 ;
28321 int res1 = 0 ;
28322 void *argp2 = 0 ;
28323 int res2 = 0 ;
28324 PyObject * obj0 = 0 ;
28325 PyObject * obj1 = 0 ;
28326 char * kwnames[] = {
28327 (char *) "self",(char *) "other", NULL
28328 };
28329
28330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
28331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28332 if (!SWIG_IsOK(res1)) {
28333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___eq__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28334 }
28335 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28337 if (!SWIG_IsOK(res2)) {
28338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___eq__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28339 }
28340 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 {
28348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28349 }
28350 return resultobj;
28351 fail:
28352 return NULL;
28353 }
28354
28355
28356 SWIGINTERN PyObject *_wrap_TimeSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28357 PyObject *resultobj = 0;
28358 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28359 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
28360 bool result;
28361 void *argp1 = 0 ;
28362 int res1 = 0 ;
28363 void *argp2 = 0 ;
28364 int res2 = 0 ;
28365 PyObject * obj0 = 0 ;
28366 PyObject * obj1 = 0 ;
28367 char * kwnames[] = {
28368 (char *) "self",(char *) "other", NULL
28369 };
28370
28371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
28372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28373 if (!SWIG_IsOK(res1)) {
28374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan___ne__" "', expected argument " "1"" of type '" "wxTimeSpan *""'");
28375 }
28376 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28378 if (!SWIG_IsOK(res2)) {
28379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan___ne__" "', expected argument " "2"" of type '" "wxTimeSpan const *""'");
28380 }
28381 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 {
28389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28390 }
28391 return resultobj;
28392 fail:
28393 return NULL;
28394 }
28395
28396
28397 SWIGINTERN PyObject *_wrap_TimeSpan_IsNull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28398 PyObject *resultobj = 0;
28399 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28400 bool result;
28401 void *argp1 = 0 ;
28402 int res1 = 0 ;
28403 PyObject *swig_obj[1] ;
28404
28405 if (!args) SWIG_fail;
28406 swig_obj[0] = args;
28407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28408 if (!SWIG_IsOK(res1)) {
28409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNull" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28410 }
28411 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28412 {
28413 PyThreadState* __tstate = wxPyBeginAllowThreads();
28414 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
28415 wxPyEndAllowThreads(__tstate);
28416 if (PyErr_Occurred()) SWIG_fail;
28417 }
28418 {
28419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28420 }
28421 return resultobj;
28422 fail:
28423 return NULL;
28424 }
28425
28426
28427 SWIGINTERN PyObject *_wrap_TimeSpan_IsPositive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28428 PyObject *resultobj = 0;
28429 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28430 bool result;
28431 void *argp1 = 0 ;
28432 int res1 = 0 ;
28433 PyObject *swig_obj[1] ;
28434
28435 if (!args) SWIG_fail;
28436 swig_obj[0] = args;
28437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28438 if (!SWIG_IsOK(res1)) {
28439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsPositive" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28440 }
28441 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
28445 wxPyEndAllowThreads(__tstate);
28446 if (PyErr_Occurred()) SWIG_fail;
28447 }
28448 {
28449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28450 }
28451 return resultobj;
28452 fail:
28453 return NULL;
28454 }
28455
28456
28457 SWIGINTERN PyObject *_wrap_TimeSpan_IsNegative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28458 PyObject *resultobj = 0;
28459 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28460 bool result;
28461 void *argp1 = 0 ;
28462 int res1 = 0 ;
28463 PyObject *swig_obj[1] ;
28464
28465 if (!args) SWIG_fail;
28466 swig_obj[0] = args;
28467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28468 if (!SWIG_IsOK(res1)) {
28469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsNegative" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28470 }
28471 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28472 {
28473 PyThreadState* __tstate = wxPyBeginAllowThreads();
28474 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
28475 wxPyEndAllowThreads(__tstate);
28476 if (PyErr_Occurred()) SWIG_fail;
28477 }
28478 {
28479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28480 }
28481 return resultobj;
28482 fail:
28483 return NULL;
28484 }
28485
28486
28487 SWIGINTERN PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28488 PyObject *resultobj = 0;
28489 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28490 wxTimeSpan *arg2 = 0 ;
28491 bool result;
28492 void *argp1 = 0 ;
28493 int res1 = 0 ;
28494 void *argp2 = 0 ;
28495 int res2 = 0 ;
28496 PyObject * obj0 = 0 ;
28497 PyObject * obj1 = 0 ;
28498 char * kwnames[] = {
28499 (char *) "self",(char *) "ts", NULL
28500 };
28501
28502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) SWIG_fail;
28503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28504 if (!SWIG_IsOK(res1)) {
28505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28506 }
28507 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28509 if (!SWIG_IsOK(res2)) {
28510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28511 }
28512 if (!argp2) {
28513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsEqualTo" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28514 }
28515 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 {
28523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28524 }
28525 return resultobj;
28526 fail:
28527 return NULL;
28528 }
28529
28530
28531 SWIGINTERN PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28532 PyObject *resultobj = 0;
28533 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28534 wxTimeSpan *arg2 = 0 ;
28535 bool result;
28536 void *argp1 = 0 ;
28537 int res1 = 0 ;
28538 void *argp2 = 0 ;
28539 int res2 = 0 ;
28540 PyObject * obj0 = 0 ;
28541 PyObject * obj1 = 0 ;
28542 char * kwnames[] = {
28543 (char *) "self",(char *) "ts", NULL
28544 };
28545
28546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) SWIG_fail;
28547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28548 if (!SWIG_IsOK(res1)) {
28549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28550 }
28551 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28552 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28553 if (!SWIG_IsOK(res2)) {
28554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28555 }
28556 if (!argp2) {
28557 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsLongerThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28558 }
28559 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 {
28567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28568 }
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 SWIGINTERN PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28576 PyObject *resultobj = 0;
28577 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28578 wxTimeSpan *arg2 = 0 ;
28579 bool result;
28580 void *argp1 = 0 ;
28581 int res1 = 0 ;
28582 void *argp2 = 0 ;
28583 int res2 = 0 ;
28584 PyObject * obj0 = 0 ;
28585 PyObject * obj1 = 0 ;
28586 char * kwnames[] = {
28587 (char *) "self",(char *) "t", NULL
28588 };
28589
28590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) SWIG_fail;
28591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28592 if (!SWIG_IsOK(res1)) {
28593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28594 }
28595 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28596 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTimeSpan, 0 | 0);
28597 if (!SWIG_IsOK(res2)) {
28598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28599 }
28600 if (!argp2) {
28601 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeSpan_IsShorterThan" "', expected argument " "2"" of type '" "wxTimeSpan const &""'");
28602 }
28603 arg2 = reinterpret_cast< wxTimeSpan * >(argp2);
28604 {
28605 PyThreadState* __tstate = wxPyBeginAllowThreads();
28606 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
28607 wxPyEndAllowThreads(__tstate);
28608 if (PyErr_Occurred()) SWIG_fail;
28609 }
28610 {
28611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28612 }
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *_wrap_TimeSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620 PyObject *resultobj = 0;
28621 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28622 int result;
28623 void *argp1 = 0 ;
28624 int res1 = 0 ;
28625 PyObject *swig_obj[1] ;
28626
28627 if (!args) SWIG_fail;
28628 swig_obj[0] = args;
28629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28630 if (!SWIG_IsOK(res1)) {
28631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetWeeks" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28632 }
28633 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 resultobj = SWIG_From_int(static_cast< int >(result));
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_TimeSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28648 PyObject *resultobj = 0;
28649 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28650 int result;
28651 void *argp1 = 0 ;
28652 int res1 = 0 ;
28653 PyObject *swig_obj[1] ;
28654
28655 if (!args) SWIG_fail;
28656 swig_obj[0] = args;
28657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28658 if (!SWIG_IsOK(res1)) {
28659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetDays" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28660 }
28661 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28662 {
28663 PyThreadState* __tstate = wxPyBeginAllowThreads();
28664 result = (int)((wxTimeSpan const *)arg1)->GetDays();
28665 wxPyEndAllowThreads(__tstate);
28666 if (PyErr_Occurred()) SWIG_fail;
28667 }
28668 resultobj = SWIG_From_int(static_cast< int >(result));
28669 return resultobj;
28670 fail:
28671 return NULL;
28672 }
28673
28674
28675 SWIGINTERN PyObject *_wrap_TimeSpan_GetHours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28676 PyObject *resultobj = 0;
28677 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28678 int result;
28679 void *argp1 = 0 ;
28680 int res1 = 0 ;
28681 PyObject *swig_obj[1] ;
28682
28683 if (!args) SWIG_fail;
28684 swig_obj[0] = args;
28685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28686 if (!SWIG_IsOK(res1)) {
28687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetHours" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28688 }
28689 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28690 {
28691 PyThreadState* __tstate = wxPyBeginAllowThreads();
28692 result = (int)((wxTimeSpan const *)arg1)->GetHours();
28693 wxPyEndAllowThreads(__tstate);
28694 if (PyErr_Occurred()) SWIG_fail;
28695 }
28696 resultobj = SWIG_From_int(static_cast< int >(result));
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 SWIGINTERN PyObject *_wrap_TimeSpan_GetMinutes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28704 PyObject *resultobj = 0;
28705 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28706 int result;
28707 void *argp1 = 0 ;
28708 int res1 = 0 ;
28709 PyObject *swig_obj[1] ;
28710
28711 if (!args) SWIG_fail;
28712 swig_obj[0] = args;
28713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28714 if (!SWIG_IsOK(res1)) {
28715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMinutes" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28716 }
28717 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28718 {
28719 PyThreadState* __tstate = wxPyBeginAllowThreads();
28720 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
28721 wxPyEndAllowThreads(__tstate);
28722 if (PyErr_Occurred()) SWIG_fail;
28723 }
28724 resultobj = SWIG_From_int(static_cast< int >(result));
28725 return resultobj;
28726 fail:
28727 return NULL;
28728 }
28729
28730
28731 SWIGINTERN PyObject *_wrap_TimeSpan_GetSeconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28732 PyObject *resultobj = 0;
28733 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28734 wxLongLong result;
28735 void *argp1 = 0 ;
28736 int res1 = 0 ;
28737 PyObject *swig_obj[1] ;
28738
28739 if (!args) SWIG_fail;
28740 swig_obj[0] = args;
28741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28742 if (!SWIG_IsOK(res1)) {
28743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetSeconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28744 }
28745 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28746 {
28747 PyThreadState* __tstate = wxPyBeginAllowThreads();
28748 result = ((wxTimeSpan const *)arg1)->GetSeconds();
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 {
28753 PyObject *hi, *lo, *shifter, *shifted;
28754 hi = PyLong_FromLong( (&result)->GetHi() );
28755 lo = PyLong_FromLong( (&result)->GetLo() );
28756 shifter = PyLong_FromLong(32);
28757 shifted = PyNumber_Lshift(hi, shifter);
28758 resultobj = PyNumber_Or(shifted, lo);
28759 Py_DECREF(hi);
28760 Py_DECREF(lo);
28761 Py_DECREF(shifter);
28762 Py_DECREF(shifted);
28763 }
28764 return resultobj;
28765 fail:
28766 return NULL;
28767 }
28768
28769
28770 SWIGINTERN PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28771 PyObject *resultobj = 0;
28772 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28773 wxLongLong result;
28774 void *argp1 = 0 ;
28775 int res1 = 0 ;
28776 PyObject *swig_obj[1] ;
28777
28778 if (!args) SWIG_fail;
28779 swig_obj[0] = args;
28780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28781 if (!SWIG_IsOK(res1)) {
28782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_GetMilliseconds" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28783 }
28784 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28785 {
28786 PyThreadState* __tstate = wxPyBeginAllowThreads();
28787 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
28788 wxPyEndAllowThreads(__tstate);
28789 if (PyErr_Occurred()) SWIG_fail;
28790 }
28791 {
28792 PyObject *hi, *lo, *shifter, *shifted;
28793 hi = PyLong_FromLong( (&result)->GetHi() );
28794 lo = PyLong_FromLong( (&result)->GetLo() );
28795 shifter = PyLong_FromLong(32);
28796 shifted = PyNumber_Lshift(hi, shifter);
28797 resultobj = PyNumber_Or(shifted, lo);
28798 Py_DECREF(hi);
28799 Py_DECREF(lo);
28800 Py_DECREF(shifter);
28801 Py_DECREF(shifted);
28802 }
28803 return resultobj;
28804 fail:
28805 return NULL;
28806 }
28807
28808
28809 SWIGINTERN PyObject *_wrap_TimeSpan_Format(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28810 PyObject *resultobj = 0;
28811 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
28812 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
28813 wxString *arg2 = (wxString *) &arg2_defvalue ;
28814 wxString result;
28815 void *argp1 = 0 ;
28816 int res1 = 0 ;
28817 bool temp2 = false ;
28818 PyObject * obj0 = 0 ;
28819 PyObject * obj1 = 0 ;
28820 char * kwnames[] = {
28821 (char *) "self",(char *) "format", NULL
28822 };
28823
28824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) SWIG_fail;
28825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTimeSpan, 0 | 0 );
28826 if (!SWIG_IsOK(res1)) {
28827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeSpan_Format" "', expected argument " "1"" of type '" "wxTimeSpan const *""'");
28828 }
28829 arg1 = reinterpret_cast< wxTimeSpan * >(argp1);
28830 if (obj1) {
28831 {
28832 arg2 = wxString_in_helper(obj1);
28833 if (arg2 == NULL) SWIG_fail;
28834 temp2 = true;
28835 }
28836 }
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
28840 wxPyEndAllowThreads(__tstate);
28841 if (PyErr_Occurred()) SWIG_fail;
28842 }
28843 {
28844 #if wxUSE_UNICODE
28845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28846 #else
28847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28848 #endif
28849 }
28850 {
28851 if (temp2)
28852 delete arg2;
28853 }
28854 return resultobj;
28855 fail:
28856 {
28857 if (temp2)
28858 delete arg2;
28859 }
28860 return NULL;
28861 }
28862
28863
28864 SWIGINTERN PyObject *TimeSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28865 PyObject *obj;
28866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28867 SWIG_TypeNewClientData(SWIGTYPE_p_wxTimeSpan, SWIG_NewClientData(obj));
28868 return SWIG_Py_Void();
28869 }
28870
28871 SWIGINTERN PyObject *TimeSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28872 return SWIG_Python_InitShadowInstance(args);
28873 }
28874
28875 SWIGINTERN PyObject *_wrap_new_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28876 PyObject *resultobj = 0;
28877 int arg1 = (int) 0 ;
28878 int arg2 = (int) 0 ;
28879 int arg3 = (int) 0 ;
28880 int arg4 = (int) 0 ;
28881 wxDateSpan *result = 0 ;
28882 int val1 ;
28883 int ecode1 = 0 ;
28884 int val2 ;
28885 int ecode2 = 0 ;
28886 int val3 ;
28887 int ecode3 = 0 ;
28888 int val4 ;
28889 int ecode4 = 0 ;
28890 PyObject * obj0 = 0 ;
28891 PyObject * obj1 = 0 ;
28892 PyObject * obj2 = 0 ;
28893 PyObject * obj3 = 0 ;
28894 char * kwnames[] = {
28895 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
28896 };
28897
28898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28899 if (obj0) {
28900 ecode1 = SWIG_AsVal_int(obj0, &val1);
28901 if (!SWIG_IsOK(ecode1)) {
28902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DateSpan" "', expected argument " "1"" of type '" "int""'");
28903 }
28904 arg1 = static_cast< int >(val1);
28905 }
28906 if (obj1) {
28907 ecode2 = SWIG_AsVal_int(obj1, &val2);
28908 if (!SWIG_IsOK(ecode2)) {
28909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DateSpan" "', expected argument " "2"" of type '" "int""'");
28910 }
28911 arg2 = static_cast< int >(val2);
28912 }
28913 if (obj2) {
28914 ecode3 = SWIG_AsVal_int(obj2, &val3);
28915 if (!SWIG_IsOK(ecode3)) {
28916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateSpan" "', expected argument " "3"" of type '" "int""'");
28917 }
28918 arg3 = static_cast< int >(val3);
28919 }
28920 if (obj3) {
28921 ecode4 = SWIG_AsVal_int(obj3, &val4);
28922 if (!SWIG_IsOK(ecode4)) {
28923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DateSpan" "', expected argument " "4"" of type '" "int""'");
28924 }
28925 arg4 = static_cast< int >(val4);
28926 }
28927 {
28928 PyThreadState* __tstate = wxPyBeginAllowThreads();
28929 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_NEW | 0 );
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 SWIGINTERN PyObject *_wrap_delete_DateSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28941 PyObject *resultobj = 0;
28942 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
28943 void *argp1 = 0 ;
28944 int res1 = 0 ;
28945 PyObject *swig_obj[1] ;
28946
28947 if (!args) SWIG_fail;
28948 swig_obj[0] = args;
28949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
28950 if (!SWIG_IsOK(res1)) {
28951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DateSpan" "', expected argument " "1"" of type '" "wxDateSpan *""'");
28952 }
28953 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 delete arg1;
28957
28958 wxPyEndAllowThreads(__tstate);
28959 if (PyErr_Occurred()) SWIG_fail;
28960 }
28961 resultobj = SWIG_Py_Void();
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 SWIGINTERN PyObject *_wrap_DateSpan_Days(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28969 PyObject *resultobj = 0;
28970 int arg1 ;
28971 wxDateSpan result;
28972 int val1 ;
28973 int ecode1 = 0 ;
28974 PyObject * obj0 = 0 ;
28975 char * kwnames[] = {
28976 (char *) "days", NULL
28977 };
28978
28979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) SWIG_fail;
28980 ecode1 = SWIG_AsVal_int(obj0, &val1);
28981 if (!SWIG_IsOK(ecode1)) {
28982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Days" "', expected argument " "1"" of type '" "int""'");
28983 }
28984 arg1 = static_cast< int >(val1);
28985 {
28986 PyThreadState* __tstate = wxPyBeginAllowThreads();
28987 result = wxDateSpan::Days(arg1);
28988 wxPyEndAllowThreads(__tstate);
28989 if (PyErr_Occurred()) SWIG_fail;
28990 }
28991 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
28992 return resultobj;
28993 fail:
28994 return NULL;
28995 }
28996
28997
28998 SWIGINTERN PyObject *_wrap_DateSpan_Day(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28999 PyObject *resultobj = 0;
29000 wxDateSpan result;
29001
29002 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Day",0,0,0)) SWIG_fail;
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 result = wxDateSpan::Day();
29006 wxPyEndAllowThreads(__tstate);
29007 if (PyErr_Occurred()) SWIG_fail;
29008 }
29009 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29010 return resultobj;
29011 fail:
29012 return NULL;
29013 }
29014
29015
29016 SWIGINTERN PyObject *_wrap_DateSpan_Weeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29017 PyObject *resultobj = 0;
29018 int arg1 ;
29019 wxDateSpan result;
29020 int val1 ;
29021 int ecode1 = 0 ;
29022 PyObject * obj0 = 0 ;
29023 char * kwnames[] = {
29024 (char *) "weeks", NULL
29025 };
29026
29027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) SWIG_fail;
29028 ecode1 = SWIG_AsVal_int(obj0, &val1);
29029 if (!SWIG_IsOK(ecode1)) {
29030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Weeks" "', expected argument " "1"" of type '" "int""'");
29031 }
29032 arg1 = static_cast< int >(val1);
29033 {
29034 PyThreadState* __tstate = wxPyBeginAllowThreads();
29035 result = wxDateSpan::Weeks(arg1);
29036 wxPyEndAllowThreads(__tstate);
29037 if (PyErr_Occurred()) SWIG_fail;
29038 }
29039 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29040 return resultobj;
29041 fail:
29042 return NULL;
29043 }
29044
29045
29046 SWIGINTERN PyObject *_wrap_DateSpan_Week(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29047 PyObject *resultobj = 0;
29048 wxDateSpan result;
29049
29050 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Week",0,0,0)) SWIG_fail;
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 result = wxDateSpan::Week();
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29058 return resultobj;
29059 fail:
29060 return NULL;
29061 }
29062
29063
29064 SWIGINTERN PyObject *_wrap_DateSpan_Months(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj = 0;
29066 int arg1 ;
29067 wxDateSpan result;
29068 int val1 ;
29069 int ecode1 = 0 ;
29070 PyObject * obj0 = 0 ;
29071 char * kwnames[] = {
29072 (char *) "mon", NULL
29073 };
29074
29075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) SWIG_fail;
29076 ecode1 = SWIG_AsVal_int(obj0, &val1);
29077 if (!SWIG_IsOK(ecode1)) {
29078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Months" "', expected argument " "1"" of type '" "int""'");
29079 }
29080 arg1 = static_cast< int >(val1);
29081 {
29082 PyThreadState* __tstate = wxPyBeginAllowThreads();
29083 result = wxDateSpan::Months(arg1);
29084 wxPyEndAllowThreads(__tstate);
29085 if (PyErr_Occurred()) SWIG_fail;
29086 }
29087 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29088 return resultobj;
29089 fail:
29090 return NULL;
29091 }
29092
29093
29094 SWIGINTERN PyObject *_wrap_DateSpan_Month(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29095 PyObject *resultobj = 0;
29096 wxDateSpan result;
29097
29098 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Month",0,0,0)) SWIG_fail;
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 result = wxDateSpan::Month();
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN PyObject *_wrap_DateSpan_Years(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29113 PyObject *resultobj = 0;
29114 int arg1 ;
29115 wxDateSpan result;
29116 int val1 ;
29117 int ecode1 = 0 ;
29118 PyObject * obj0 = 0 ;
29119 char * kwnames[] = {
29120 (char *) "years", NULL
29121 };
29122
29123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) SWIG_fail;
29124 ecode1 = SWIG_AsVal_int(obj0, &val1);
29125 if (!SWIG_IsOK(ecode1)) {
29126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DateSpan_Years" "', expected argument " "1"" of type '" "int""'");
29127 }
29128 arg1 = static_cast< int >(val1);
29129 {
29130 PyThreadState* __tstate = wxPyBeginAllowThreads();
29131 result = wxDateSpan::Years(arg1);
29132 wxPyEndAllowThreads(__tstate);
29133 if (PyErr_Occurred()) SWIG_fail;
29134 }
29135 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 SWIGINTERN PyObject *_wrap_DateSpan_Year(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29143 PyObject *resultobj = 0;
29144 wxDateSpan result;
29145
29146 if (!SWIG_Python_UnpackTuple(args,"DateSpan_Year",0,0,0)) SWIG_fail;
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 result = wxDateSpan::Year();
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29154 return resultobj;
29155 fail:
29156 return NULL;
29157 }
29158
29159
29160 SWIGINTERN PyObject *_wrap_DateSpan_SetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29161 PyObject *resultobj = 0;
29162 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29163 int arg2 ;
29164 wxDateSpan *result = 0 ;
29165 void *argp1 = 0 ;
29166 int res1 = 0 ;
29167 int val2 ;
29168 int ecode2 = 0 ;
29169 PyObject * obj0 = 0 ;
29170 PyObject * obj1 = 0 ;
29171 char * kwnames[] = {
29172 (char *) "self",(char *) "n", NULL
29173 };
29174
29175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) SWIG_fail;
29176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29177 if (!SWIG_IsOK(res1)) {
29178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetYears" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29179 }
29180 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29181 ecode2 = SWIG_AsVal_int(obj1, &val2);
29182 if (!SWIG_IsOK(ecode2)) {
29183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetYears" "', expected argument " "2"" of type '" "int""'");
29184 }
29185 arg2 = static_cast< int >(val2);
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 {
29189 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
29190 result = (wxDateSpan *) &_result_ref;
29191 }
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *_wrap_DateSpan_SetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29203 PyObject *resultobj = 0;
29204 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29205 int arg2 ;
29206 wxDateSpan *result = 0 ;
29207 void *argp1 = 0 ;
29208 int res1 = 0 ;
29209 int val2 ;
29210 int ecode2 = 0 ;
29211 PyObject * obj0 = 0 ;
29212 PyObject * obj1 = 0 ;
29213 char * kwnames[] = {
29214 (char *) "self",(char *) "n", NULL
29215 };
29216
29217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) SWIG_fail;
29218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29219 if (!SWIG_IsOK(res1)) {
29220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetMonths" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29221 }
29222 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29223 ecode2 = SWIG_AsVal_int(obj1, &val2);
29224 if (!SWIG_IsOK(ecode2)) {
29225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetMonths" "', expected argument " "2"" of type '" "int""'");
29226 }
29227 arg2 = static_cast< int >(val2);
29228 {
29229 PyThreadState* __tstate = wxPyBeginAllowThreads();
29230 {
29231 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
29232 result = (wxDateSpan *) &_result_ref;
29233 }
29234 wxPyEndAllowThreads(__tstate);
29235 if (PyErr_Occurred()) SWIG_fail;
29236 }
29237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29238 return resultobj;
29239 fail:
29240 return NULL;
29241 }
29242
29243
29244 SWIGINTERN PyObject *_wrap_DateSpan_SetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29245 PyObject *resultobj = 0;
29246 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29247 int arg2 ;
29248 wxDateSpan *result = 0 ;
29249 void *argp1 = 0 ;
29250 int res1 = 0 ;
29251 int val2 ;
29252 int ecode2 = 0 ;
29253 PyObject * obj0 = 0 ;
29254 PyObject * obj1 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "self",(char *) "n", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) SWIG_fail;
29260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29261 if (!SWIG_IsOK(res1)) {
29262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetWeeks" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29263 }
29264 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29265 ecode2 = SWIG_AsVal_int(obj1, &val2);
29266 if (!SWIG_IsOK(ecode2)) {
29267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetWeeks" "', expected argument " "2"" of type '" "int""'");
29268 }
29269 arg2 = static_cast< int >(val2);
29270 {
29271 PyThreadState* __tstate = wxPyBeginAllowThreads();
29272 {
29273 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
29274 result = (wxDateSpan *) &_result_ref;
29275 }
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_DateSpan_SetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj = 0;
29288 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29289 int arg2 ;
29290 wxDateSpan *result = 0 ;
29291 void *argp1 = 0 ;
29292 int res1 = 0 ;
29293 int val2 ;
29294 int ecode2 = 0 ;
29295 PyObject * obj0 = 0 ;
29296 PyObject * obj1 = 0 ;
29297 char * kwnames[] = {
29298 (char *) "self",(char *) "n", NULL
29299 };
29300
29301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) SWIG_fail;
29302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29303 if (!SWIG_IsOK(res1)) {
29304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_SetDays" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29305 }
29306 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29307 ecode2 = SWIG_AsVal_int(obj1, &val2);
29308 if (!SWIG_IsOK(ecode2)) {
29309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_SetDays" "', expected argument " "2"" of type '" "int""'");
29310 }
29311 arg2 = static_cast< int >(val2);
29312 {
29313 PyThreadState* __tstate = wxPyBeginAllowThreads();
29314 {
29315 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
29316 result = (wxDateSpan *) &_result_ref;
29317 }
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29322 return resultobj;
29323 fail:
29324 return NULL;
29325 }
29326
29327
29328 SWIGINTERN PyObject *_wrap_DateSpan_GetYears(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29329 PyObject *resultobj = 0;
29330 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29331 int result;
29332 void *argp1 = 0 ;
29333 int res1 = 0 ;
29334 PyObject *swig_obj[1] ;
29335
29336 if (!args) SWIG_fail;
29337 swig_obj[0] = args;
29338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29339 if (!SWIG_IsOK(res1)) {
29340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetYears" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29341 }
29342 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29343 {
29344 PyThreadState* __tstate = wxPyBeginAllowThreads();
29345 result = (int)((wxDateSpan const *)arg1)->GetYears();
29346 wxPyEndAllowThreads(__tstate);
29347 if (PyErr_Occurred()) SWIG_fail;
29348 }
29349 resultobj = SWIG_From_int(static_cast< int >(result));
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 SWIGINTERN PyObject *_wrap_DateSpan_GetMonths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29357 PyObject *resultobj = 0;
29358 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29359 int result;
29360 void *argp1 = 0 ;
29361 int res1 = 0 ;
29362 PyObject *swig_obj[1] ;
29363
29364 if (!args) SWIG_fail;
29365 swig_obj[0] = args;
29366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29367 if (!SWIG_IsOK(res1)) {
29368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetMonths" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29369 }
29370 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29371 {
29372 PyThreadState* __tstate = wxPyBeginAllowThreads();
29373 result = (int)((wxDateSpan const *)arg1)->GetMonths();
29374 wxPyEndAllowThreads(__tstate);
29375 if (PyErr_Occurred()) SWIG_fail;
29376 }
29377 resultobj = SWIG_From_int(static_cast< int >(result));
29378 return resultobj;
29379 fail:
29380 return NULL;
29381 }
29382
29383
29384 SWIGINTERN PyObject *_wrap_DateSpan_GetWeeks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29385 PyObject *resultobj = 0;
29386 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29387 int result;
29388 void *argp1 = 0 ;
29389 int res1 = 0 ;
29390 PyObject *swig_obj[1] ;
29391
29392 if (!args) SWIG_fail;
29393 swig_obj[0] = args;
29394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29395 if (!SWIG_IsOK(res1)) {
29396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetWeeks" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29397 }
29398 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29399 {
29400 PyThreadState* __tstate = wxPyBeginAllowThreads();
29401 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
29402 wxPyEndAllowThreads(__tstate);
29403 if (PyErr_Occurred()) SWIG_fail;
29404 }
29405 resultobj = SWIG_From_int(static_cast< int >(result));
29406 return resultobj;
29407 fail:
29408 return NULL;
29409 }
29410
29411
29412 SWIGINTERN PyObject *_wrap_DateSpan_GetDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29413 PyObject *resultobj = 0;
29414 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29415 int result;
29416 void *argp1 = 0 ;
29417 int res1 = 0 ;
29418 PyObject *swig_obj[1] ;
29419
29420 if (!args) SWIG_fail;
29421 swig_obj[0] = args;
29422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29423 if (!SWIG_IsOK(res1)) {
29424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29425 }
29426 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29427 {
29428 PyThreadState* __tstate = wxPyBeginAllowThreads();
29429 result = (int)((wxDateSpan const *)arg1)->GetDays();
29430 wxPyEndAllowThreads(__tstate);
29431 if (PyErr_Occurred()) SWIG_fail;
29432 }
29433 resultobj = SWIG_From_int(static_cast< int >(result));
29434 return resultobj;
29435 fail:
29436 return NULL;
29437 }
29438
29439
29440 SWIGINTERN PyObject *_wrap_DateSpan_GetTotalDays(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29441 PyObject *resultobj = 0;
29442 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29443 int result;
29444 void *argp1 = 0 ;
29445 int res1 = 0 ;
29446 PyObject *swig_obj[1] ;
29447
29448 if (!args) SWIG_fail;
29449 swig_obj[0] = args;
29450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29451 if (!SWIG_IsOK(res1)) {
29452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_GetTotalDays" "', expected argument " "1"" of type '" "wxDateSpan const *""'");
29453 }
29454 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29455 {
29456 PyThreadState* __tstate = wxPyBeginAllowThreads();
29457 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
29458 wxPyEndAllowThreads(__tstate);
29459 if (PyErr_Occurred()) SWIG_fail;
29460 }
29461 resultobj = SWIG_From_int(static_cast< int >(result));
29462 return resultobj;
29463 fail:
29464 return NULL;
29465 }
29466
29467
29468 SWIGINTERN PyObject *_wrap_DateSpan_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29469 PyObject *resultobj = 0;
29470 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29471 wxDateSpan *arg2 = 0 ;
29472 wxDateSpan *result = 0 ;
29473 void *argp1 = 0 ;
29474 int res1 = 0 ;
29475 void *argp2 = 0 ;
29476 int res2 = 0 ;
29477 PyObject * obj0 = 0 ;
29478 PyObject * obj1 = 0 ;
29479 char * kwnames[] = {
29480 (char *) "self",(char *) "other", NULL
29481 };
29482
29483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) SWIG_fail;
29484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29485 if (!SWIG_IsOK(res1)) {
29486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Add" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29487 }
29488 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29489 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29490 if (!SWIG_IsOK(res2)) {
29491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29492 }
29493 if (!argp2) {
29494 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Add" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29495 }
29496 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 {
29500 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
29501 result = (wxDateSpan *) &_result_ref;
29502 }
29503 wxPyEndAllowThreads(__tstate);
29504 if (PyErr_Occurred()) SWIG_fail;
29505 }
29506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29507 return resultobj;
29508 fail:
29509 return NULL;
29510 }
29511
29512
29513 SWIGINTERN PyObject *_wrap_DateSpan_Subtract(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29514 PyObject *resultobj = 0;
29515 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29516 wxDateSpan *arg2 = 0 ;
29517 wxDateSpan *result = 0 ;
29518 void *argp1 = 0 ;
29519 int res1 = 0 ;
29520 void *argp2 = 0 ;
29521 int res2 = 0 ;
29522 PyObject * obj0 = 0 ;
29523 PyObject * obj1 = 0 ;
29524 char * kwnames[] = {
29525 (char *) "self",(char *) "other", NULL
29526 };
29527
29528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) SWIG_fail;
29529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29530 if (!SWIG_IsOK(res1)) {
29531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Subtract" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29532 }
29533 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29534 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29535 if (!SWIG_IsOK(res2)) {
29536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29537 }
29538 if (!argp2) {
29539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan_Subtract" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29540 }
29541 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29542 {
29543 PyThreadState* __tstate = wxPyBeginAllowThreads();
29544 {
29545 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
29546 result = (wxDateSpan *) &_result_ref;
29547 }
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29552 return resultobj;
29553 fail:
29554 return NULL;
29555 }
29556
29557
29558 SWIGINTERN PyObject *_wrap_DateSpan_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29559 PyObject *resultobj = 0;
29560 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29561 wxDateSpan *result = 0 ;
29562 void *argp1 = 0 ;
29563 int res1 = 0 ;
29564 PyObject *swig_obj[1] ;
29565
29566 if (!args) SWIG_fail;
29567 swig_obj[0] = args;
29568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29569 if (!SWIG_IsOK(res1)) {
29570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Neg" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29571 }
29572 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29573 {
29574 PyThreadState* __tstate = wxPyBeginAllowThreads();
29575 {
29576 wxDateSpan &_result_ref = (arg1)->Neg();
29577 result = (wxDateSpan *) &_result_ref;
29578 }
29579 wxPyEndAllowThreads(__tstate);
29580 if (PyErr_Occurred()) SWIG_fail;
29581 }
29582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29583 return resultobj;
29584 fail:
29585 return NULL;
29586 }
29587
29588
29589 SWIGINTERN PyObject *_wrap_DateSpan_Multiply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj = 0;
29591 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29592 int arg2 ;
29593 wxDateSpan *result = 0 ;
29594 void *argp1 = 0 ;
29595 int res1 = 0 ;
29596 int val2 ;
29597 int ecode2 = 0 ;
29598 PyObject * obj0 = 0 ;
29599 PyObject * obj1 = 0 ;
29600 char * kwnames[] = {
29601 (char *) "self",(char *) "factor", NULL
29602 };
29603
29604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) SWIG_fail;
29605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29606 if (!SWIG_IsOK(res1)) {
29607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan_Multiply" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29608 }
29609 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29610 ecode2 = SWIG_AsVal_int(obj1, &val2);
29611 if (!SWIG_IsOK(ecode2)) {
29612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan_Multiply" "', expected argument " "2"" of type '" "int""'");
29613 }
29614 arg2 = static_cast< int >(val2);
29615 {
29616 PyThreadState* __tstate = wxPyBeginAllowThreads();
29617 {
29618 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
29619 result = (wxDateSpan *) &_result_ref;
29620 }
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 SWIGINTERN PyObject *_wrap_DateSpan___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj = 0;
29633 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29634 wxDateSpan *arg2 = 0 ;
29635 wxDateSpan *result = 0 ;
29636 void *argp1 = 0 ;
29637 int res1 = 0 ;
29638 void *argp2 = 0 ;
29639 int res2 = 0 ;
29640 PyObject * obj0 = 0 ;
29641 PyObject * obj1 = 0 ;
29642 char * kwnames[] = {
29643 (char *) "self",(char *) "other", NULL
29644 };
29645
29646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
29647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29648 if (!SWIG_IsOK(res1)) {
29649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___iadd__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29650 }
29651 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29653 if (!SWIG_IsOK(res2)) {
29654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29655 }
29656 if (!argp2) {
29657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___iadd__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29658 }
29659 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29660 {
29661 PyThreadState* __tstate = wxPyBeginAllowThreads();
29662 {
29663 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
29664 result = (wxDateSpan *) &_result_ref;
29665 }
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29670 return resultobj;
29671 fail:
29672 return NULL;
29673 }
29674
29675
29676 SWIGINTERN PyObject *_wrap_DateSpan___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29677 PyObject *resultobj = 0;
29678 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29679 wxDateSpan *arg2 = 0 ;
29680 wxDateSpan *result = 0 ;
29681 void *argp1 = 0 ;
29682 int res1 = 0 ;
29683 void *argp2 = 0 ;
29684 int res2 = 0 ;
29685 PyObject * obj0 = 0 ;
29686 PyObject * obj1 = 0 ;
29687 char * kwnames[] = {
29688 (char *) "self",(char *) "other", NULL
29689 };
29690
29691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
29692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29693 if (!SWIG_IsOK(res1)) {
29694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___isub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29695 }
29696 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29698 if (!SWIG_IsOK(res2)) {
29699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29700 }
29701 if (!argp2) {
29702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___isub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29703 }
29704 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 {
29708 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
29709 result = (wxDateSpan *) &_result_ref;
29710 }
29711 wxPyEndAllowThreads(__tstate);
29712 if (PyErr_Occurred()) SWIG_fail;
29713 }
29714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29715 return resultobj;
29716 fail:
29717 return NULL;
29718 }
29719
29720
29721 SWIGINTERN PyObject *_wrap_DateSpan___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29722 PyObject *resultobj = 0;
29723 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29724 wxDateSpan *result = 0 ;
29725 void *argp1 = 0 ;
29726 int res1 = 0 ;
29727 PyObject *swig_obj[1] ;
29728
29729 if (!args) SWIG_fail;
29730 swig_obj[0] = args;
29731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29732 if (!SWIG_IsOK(res1)) {
29733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___neg__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29734 }
29735 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 {
29739 wxDateSpan &_result_ref = (arg1)->operator -();
29740 result = (wxDateSpan *) &_result_ref;
29741 }
29742 wxPyEndAllowThreads(__tstate);
29743 if (PyErr_Occurred()) SWIG_fail;
29744 }
29745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, 0 | 0 );
29746 return resultobj;
29747 fail:
29748 return NULL;
29749 }
29750
29751
29752 SWIGINTERN PyObject *_wrap_DateSpan___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29753 PyObject *resultobj = 0;
29754 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29755 int arg2 ;
29756 wxDateSpan *result = 0 ;
29757 void *argp1 = 0 ;
29758 int res1 = 0 ;
29759 int val2 ;
29760 int ecode2 = 0 ;
29761 PyObject * obj0 = 0 ;
29762 PyObject * obj1 = 0 ;
29763 char * kwnames[] = {
29764 (char *) "self",(char *) "factor", NULL
29765 };
29766
29767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
29768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, SWIG_POINTER_DISOWN | 0 );
29769 if (!SWIG_IsOK(res1)) {
29770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___imul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29771 }
29772 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29773 ecode2 = SWIG_AsVal_int(obj1, &val2);
29774 if (!SWIG_IsOK(ecode2)) {
29775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___imul__" "', expected argument " "2"" of type '" "int""'");
29776 }
29777 arg2 = static_cast< int >(val2);
29778 {
29779 PyThreadState* __tstate = wxPyBeginAllowThreads();
29780 {
29781 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
29782 result = (wxDateSpan *) &_result_ref;
29783 }
29784 wxPyEndAllowThreads(__tstate);
29785 if (PyErr_Occurred()) SWIG_fail;
29786 }
29787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29788 return resultobj;
29789 fail:
29790 return NULL;
29791 }
29792
29793
29794 SWIGINTERN PyObject *_wrap_DateSpan___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29795 PyObject *resultobj = 0;
29796 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29797 wxDateSpan *arg2 = 0 ;
29798 wxDateSpan result;
29799 void *argp1 = 0 ;
29800 int res1 = 0 ;
29801 void *argp2 = 0 ;
29802 int res2 = 0 ;
29803 PyObject * obj0 = 0 ;
29804 PyObject * obj1 = 0 ;
29805 char * kwnames[] = {
29806 (char *) "self",(char *) "other", NULL
29807 };
29808
29809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) SWIG_fail;
29810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29811 if (!SWIG_IsOK(res1)) {
29812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___add__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29813 }
29814 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29815 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29816 if (!SWIG_IsOK(res2)) {
29817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29818 }
29819 if (!argp2) {
29820 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___add__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29821 }
29822 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29830 return resultobj;
29831 fail:
29832 return NULL;
29833 }
29834
29835
29836 SWIGINTERN PyObject *_wrap_DateSpan___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29837 PyObject *resultobj = 0;
29838 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29839 wxDateSpan *arg2 = 0 ;
29840 wxDateSpan result;
29841 void *argp1 = 0 ;
29842 int res1 = 0 ;
29843 void *argp2 = 0 ;
29844 int res2 = 0 ;
29845 PyObject * obj0 = 0 ;
29846 PyObject * obj1 = 0 ;
29847 char * kwnames[] = {
29848 (char *) "self",(char *) "other", NULL
29849 };
29850
29851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
29852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29853 if (!SWIG_IsOK(res1)) {
29854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___sub__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29855 }
29856 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateSpan, 0 | 0);
29858 if (!SWIG_IsOK(res2)) {
29859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29860 }
29861 if (!argp2) {
29862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateSpan___sub__" "', expected argument " "2"" of type '" "wxDateSpan const &""'");
29863 }
29864 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29865 {
29866 PyThreadState* __tstate = wxPyBeginAllowThreads();
29867 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
29868 wxPyEndAllowThreads(__tstate);
29869 if (PyErr_Occurred()) SWIG_fail;
29870 }
29871 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29872 return resultobj;
29873 fail:
29874 return NULL;
29875 }
29876
29877
29878 SWIGINTERN PyObject *_wrap_DateSpan___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29879 PyObject *resultobj = 0;
29880 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29881 int arg2 ;
29882 wxDateSpan result;
29883 void *argp1 = 0 ;
29884 int res1 = 0 ;
29885 int val2 ;
29886 int ecode2 = 0 ;
29887 PyObject * obj0 = 0 ;
29888 PyObject * obj1 = 0 ;
29889 char * kwnames[] = {
29890 (char *) "self",(char *) "n", NULL
29891 };
29892
29893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) SWIG_fail;
29894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29895 if (!SWIG_IsOK(res1)) {
29896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___mul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29897 }
29898 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29899 ecode2 = SWIG_AsVal_int(obj1, &val2);
29900 if (!SWIG_IsOK(ecode2)) {
29901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___mul__" "', expected argument " "2"" of type '" "int""'");
29902 }
29903 arg2 = static_cast< int >(val2);
29904 {
29905 PyThreadState* __tstate = wxPyBeginAllowThreads();
29906 result = wxDateSpan___mul__(arg1,arg2);
29907 wxPyEndAllowThreads(__tstate);
29908 if (PyErr_Occurred()) SWIG_fail;
29909 }
29910 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29911 return resultobj;
29912 fail:
29913 return NULL;
29914 }
29915
29916
29917 SWIGINTERN PyObject *_wrap_DateSpan___rmul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29918 PyObject *resultobj = 0;
29919 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29920 int arg2 ;
29921 wxDateSpan result;
29922 void *argp1 = 0 ;
29923 int res1 = 0 ;
29924 int val2 ;
29925 int ecode2 = 0 ;
29926 PyObject * obj0 = 0 ;
29927 PyObject * obj1 = 0 ;
29928 char * kwnames[] = {
29929 (char *) "self",(char *) "n", NULL
29930 };
29931
29932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) SWIG_fail;
29933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29934 if (!SWIG_IsOK(res1)) {
29935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___rmul__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29936 }
29937 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29938 ecode2 = SWIG_AsVal_int(obj1, &val2);
29939 if (!SWIG_IsOK(ecode2)) {
29940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DateSpan___rmul__" "', expected argument " "2"" of type '" "int""'");
29941 }
29942 arg2 = static_cast< int >(val2);
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 result = wxDateSpan___rmul__(arg1,arg2);
29946 wxPyEndAllowThreads(__tstate);
29947 if (PyErr_Occurred()) SWIG_fail;
29948 }
29949 resultobj = SWIG_NewPointerObj((new wxDateSpan(static_cast< const wxDateSpan& >(result))), SWIGTYPE_p_wxDateSpan, SWIG_POINTER_OWN | 0 );
29950 return resultobj;
29951 fail:
29952 return NULL;
29953 }
29954
29955
29956 SWIGINTERN PyObject *_wrap_DateSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29957 PyObject *resultobj = 0;
29958 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
29959 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
29960 bool result;
29961 void *argp1 = 0 ;
29962 int res1 = 0 ;
29963 void *argp2 = 0 ;
29964 int res2 = 0 ;
29965 PyObject * obj0 = 0 ;
29966 PyObject * obj1 = 0 ;
29967 char * kwnames[] = {
29968 (char *) "self",(char *) "other", NULL
29969 };
29970
29971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
29972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29973 if (!SWIG_IsOK(res1)) {
29974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___eq__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
29975 }
29976 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
29977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
29978 if (!SWIG_IsOK(res2)) {
29979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___eq__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
29980 }
29981 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 {
29989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29990 }
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 SWIGINTERN PyObject *_wrap_DateSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29998 PyObject *resultobj = 0;
29999 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
30000 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
30001 bool result;
30002 void *argp1 = 0 ;
30003 int res1 = 0 ;
30004 void *argp2 = 0 ;
30005 int res2 = 0 ;
30006 PyObject * obj0 = 0 ;
30007 PyObject * obj1 = 0 ;
30008 char * kwnames[] = {
30009 (char *) "self",(char *) "other", NULL
30010 };
30011
30012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
30013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30014 if (!SWIG_IsOK(res1)) {
30015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateSpan___ne__" "', expected argument " "1"" of type '" "wxDateSpan *""'");
30016 }
30017 arg1 = reinterpret_cast< wxDateSpan * >(argp1);
30018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDateSpan, 0 | 0 );
30019 if (!SWIG_IsOK(res2)) {
30020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateSpan___ne__" "', expected argument " "2"" of type '" "wxDateSpan const *""'");
30021 }
30022 arg2 = reinterpret_cast< wxDateSpan * >(argp2);
30023 {
30024 PyThreadState* __tstate = wxPyBeginAllowThreads();
30025 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
30026 wxPyEndAllowThreads(__tstate);
30027 if (PyErr_Occurred()) SWIG_fail;
30028 }
30029 {
30030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30031 }
30032 return resultobj;
30033 fail:
30034 return NULL;
30035 }
30036
30037
30038 SWIGINTERN PyObject *DateSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30039 PyObject *obj;
30040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30041 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateSpan, SWIG_NewClientData(obj));
30042 return SWIG_Py_Void();
30043 }
30044
30045 SWIGINTERN PyObject *DateSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30046 return SWIG_Python_InitShadowInstance(args);
30047 }
30048
30049 SWIGINTERN PyObject *_wrap_GetLocalTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30050 PyObject *resultobj = 0;
30051 long result;
30052
30053 if (!SWIG_Python_UnpackTuple(args,"GetLocalTime",0,0,0)) SWIG_fail;
30054 {
30055 PyThreadState* __tstate = wxPyBeginAllowThreads();
30056 result = (long)wxGetLocalTime();
30057 wxPyEndAllowThreads(__tstate);
30058 if (PyErr_Occurred()) SWIG_fail;
30059 }
30060 resultobj = SWIG_From_long(static_cast< long >(result));
30061 return resultobj;
30062 fail:
30063 return NULL;
30064 }
30065
30066
30067 SWIGINTERN PyObject *_wrap_GetUTCTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30068 PyObject *resultobj = 0;
30069 long result;
30070
30071 if (!SWIG_Python_UnpackTuple(args,"GetUTCTime",0,0,0)) SWIG_fail;
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (long)wxGetUTCTime();
30075 wxPyEndAllowThreads(__tstate);
30076 if (PyErr_Occurred()) SWIG_fail;
30077 }
30078 resultobj = SWIG_From_long(static_cast< long >(result));
30079 return resultobj;
30080 fail:
30081 return NULL;
30082 }
30083
30084
30085 SWIGINTERN PyObject *_wrap_GetCurrentTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30086 PyObject *resultobj = 0;
30087 long result;
30088
30089 if (!SWIG_Python_UnpackTuple(args,"GetCurrentTime",0,0,0)) SWIG_fail;
30090 {
30091 PyThreadState* __tstate = wxPyBeginAllowThreads();
30092 result = (long)wxGetCurrentTime();
30093 wxPyEndAllowThreads(__tstate);
30094 if (PyErr_Occurred()) SWIG_fail;
30095 }
30096 resultobj = SWIG_From_long(static_cast< long >(result));
30097 return resultobj;
30098 fail:
30099 return NULL;
30100 }
30101
30102
30103 SWIGINTERN PyObject *_wrap_GetLocalTimeMillis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30104 PyObject *resultobj = 0;
30105 wxLongLong result;
30106
30107 if (!SWIG_Python_UnpackTuple(args,"GetLocalTimeMillis",0,0,0)) SWIG_fail;
30108 {
30109 PyThreadState* __tstate = wxPyBeginAllowThreads();
30110 result = wxGetLocalTimeMillis();
30111 wxPyEndAllowThreads(__tstate);
30112 if (PyErr_Occurred()) SWIG_fail;
30113 }
30114 {
30115 PyObject *hi, *lo, *shifter, *shifted;
30116 hi = PyLong_FromLong( (&result)->GetHi() );
30117 lo = PyLong_FromLong( (&result)->GetLo() );
30118 shifter = PyLong_FromLong(32);
30119 shifted = PyNumber_Lshift(hi, shifter);
30120 resultobj = PyNumber_Or(shifted, lo);
30121 Py_DECREF(hi);
30122 Py_DECREF(lo);
30123 Py_DECREF(shifter);
30124 Py_DECREF(shifted);
30125 }
30126 return resultobj;
30127 fail:
30128 return NULL;
30129 }
30130
30131
30132 SWIGINTERN int DefaultDateTime_set(PyObject *) {
30133 SWIG_Error(SWIG_AttributeError,"Variable DefaultDateTime is read-only.");
30134 return 1;
30135 }
30136
30137
30138 SWIGINTERN PyObject *DefaultDateTime_get(void) {
30139 PyObject *pyobj = 0;
30140
30141 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0 );
30142 return pyobj;
30143 }
30144
30145
30146 SWIGINTERN PyObject *_wrap_new_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj = 0;
30148 wxDataFormatId arg1 ;
30149 wxDataFormat *result = 0 ;
30150 int val1 ;
30151 int ecode1 = 0 ;
30152 PyObject * obj0 = 0 ;
30153 char * kwnames[] = {
30154 (char *) "type", NULL
30155 };
30156
30157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) SWIG_fail;
30158 ecode1 = SWIG_AsVal_int(obj0, &val1);
30159 if (!SWIG_IsOK(ecode1)) {
30160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DataFormat" "', expected argument " "1"" of type '" "wxDataFormatId""'");
30161 }
30162 arg1 = static_cast< wxDataFormatId >(val1);
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 result = (wxDataFormat *)new wxDataFormat(arg1);
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_NEW | 0 );
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_new_CustomDataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj = 0;
30178 wxString *arg1 = 0 ;
30179 wxDataFormat *result = 0 ;
30180 bool temp1 = false ;
30181 PyObject * obj0 = 0 ;
30182 char * kwnames[] = {
30183 (char *) "format", NULL
30184 };
30185
30186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) SWIG_fail;
30187 {
30188 arg1 = wxString_in_helper(obj0);
30189 if (arg1 == NULL) SWIG_fail;
30190 temp1 = true;
30191 }
30192 {
30193 PyThreadState* __tstate = wxPyBeginAllowThreads();
30194 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
30195 wxPyEndAllowThreads(__tstate);
30196 if (PyErr_Occurred()) SWIG_fail;
30197 }
30198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30199 {
30200 if (temp1)
30201 delete arg1;
30202 }
30203 return resultobj;
30204 fail:
30205 {
30206 if (temp1)
30207 delete arg1;
30208 }
30209 return NULL;
30210 }
30211
30212
30213 SWIGINTERN PyObject *_wrap_delete_DataFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30214 PyObject *resultobj = 0;
30215 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30216 void *argp1 = 0 ;
30217 int res1 = 0 ;
30218 PyObject *swig_obj[1] ;
30219
30220 if (!args) SWIG_fail;
30221 swig_obj[0] = args;
30222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, SWIG_POINTER_DISOWN | 0 );
30223 if (!SWIG_IsOK(res1)) {
30224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataFormat" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30225 }
30226 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30227 {
30228 PyThreadState* __tstate = wxPyBeginAllowThreads();
30229 delete arg1;
30230
30231 wxPyEndAllowThreads(__tstate);
30232 if (PyErr_Occurred()) SWIG_fail;
30233 }
30234 resultobj = SWIG_Py_Void();
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30242 PyObject *resultobj = 0;
30243 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30244 wxDataFormatId arg2 ;
30245 bool result;
30246 void *argp1 = 0 ;
30247 int res1 = 0 ;
30248 int val2 ;
30249 int ecode2 = 0 ;
30250
30251 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30253 if (!SWIG_IsOK(res1)) {
30254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30255 }
30256 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30257 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30258 if (!SWIG_IsOK(ecode2)) {
30259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30260 }
30261 arg2 = static_cast< wxDataFormatId >(val2);
30262 {
30263 PyThreadState* __tstate = wxPyBeginAllowThreads();
30264 result = (bool)((wxDataFormat const *)arg1)->operator ==(arg2);
30265 wxPyEndAllowThreads(__tstate);
30266 if (PyErr_Occurred()) SWIG_fail;
30267 }
30268 {
30269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30270 }
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30278 PyObject *resultobj = 0;
30279 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30280 wxDataFormatId arg2 ;
30281 bool result;
30282 void *argp1 = 0 ;
30283 int res1 = 0 ;
30284 int val2 ;
30285 int ecode2 = 0 ;
30286
30287 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30289 if (!SWIG_IsOK(res1)) {
30290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30291 }
30292 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30293 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
30294 if (!SWIG_IsOK(ecode2)) {
30295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30296 }
30297 arg2 = static_cast< wxDataFormatId >(val2);
30298 {
30299 PyThreadState* __tstate = wxPyBeginAllowThreads();
30300 result = (bool)((wxDataFormat const *)arg1)->operator !=(arg2);
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 {
30305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30306 }
30307 return resultobj;
30308 fail:
30309 return NULL;
30310 }
30311
30312
30313 SWIGINTERN PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30314 PyObject *resultobj = 0;
30315 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30316 wxDataFormat *arg2 = 0 ;
30317 bool result;
30318 void *argp1 = 0 ;
30319 int res1 = 0 ;
30320 void *argp2 = 0 ;
30321 int res2 = 0 ;
30322
30323 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30325 if (!SWIG_IsOK(res1)) {
30326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___eq__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30327 }
30328 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30329 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30330 if (!SWIG_IsOK(res2)) {
30331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30332 }
30333 if (!argp2) {
30334 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___eq__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30335 }
30336 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
30340 wxPyEndAllowThreads(__tstate);
30341 if (PyErr_Occurred()) SWIG_fail;
30342 }
30343 {
30344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30345 }
30346 return resultobj;
30347 fail:
30348 return NULL;
30349 }
30350
30351
30352 SWIGINTERN PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
30353 int argc;
30354 PyObject *argv[3];
30355
30356 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___eq__",0,2,argv))) SWIG_fail;
30357 --argc;
30358 if (argc == 2) {
30359 int _v = 0;
30360 {
30361 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30362 _v = SWIG_CheckState(res);
30363 }
30364 if (!_v) goto check_1;
30365 return _wrap_DataFormat___eq____SWIG_1(self, argc, argv);
30366 }
30367 check_1:
30368
30369 if (argc == 2) {
30370 return _wrap_DataFormat___eq____SWIG_0(self, argc, argv);
30371 }
30372
30373 fail:
30374 Py_INCREF(Py_NotImplemented);
30375 return Py_NotImplemented;
30376 }
30377
30378
30379 SWIGINTERN PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
30380 PyObject *resultobj = 0;
30381 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30382 wxDataFormat *arg2 = 0 ;
30383 bool result;
30384 void *argp1 = 0 ;
30385 int res1 = 0 ;
30386 void *argp2 = 0 ;
30387 int res2 = 0 ;
30388
30389 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
30390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30391 if (!SWIG_IsOK(res1)) {
30392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat___ne__" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30393 }
30394 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30395 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30396 if (!SWIG_IsOK(res2)) {
30397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30398 }
30399 if (!argp2) {
30400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataFormat___ne__" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30401 }
30402 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30403 {
30404 PyThreadState* __tstate = wxPyBeginAllowThreads();
30405 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
30406 wxPyEndAllowThreads(__tstate);
30407 if (PyErr_Occurred()) SWIG_fail;
30408 }
30409 {
30410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30411 }
30412 return resultobj;
30413 fail:
30414 return NULL;
30415 }
30416
30417
30418 SWIGINTERN PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
30419 int argc;
30420 PyObject *argv[3];
30421
30422 if (!(argc = SWIG_Python_UnpackTuple(args,"DataFormat___ne__",0,2,argv))) SWIG_fail;
30423 --argc;
30424 if (argc == 2) {
30425 int _v = 0;
30426 {
30427 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxDataFormat, 0);
30428 _v = SWIG_CheckState(res);
30429 }
30430 if (!_v) goto check_1;
30431 return _wrap_DataFormat___ne____SWIG_1(self, argc, argv);
30432 }
30433 check_1:
30434
30435 if (argc == 2) {
30436 return _wrap_DataFormat___ne____SWIG_0(self, argc, argv);
30437 }
30438
30439 fail:
30440 Py_INCREF(Py_NotImplemented);
30441 return Py_NotImplemented;
30442 }
30443
30444
30445 SWIGINTERN PyObject *_wrap_DataFormat_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30446 PyObject *resultobj = 0;
30447 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30448 wxDataFormatId arg2 ;
30449 void *argp1 = 0 ;
30450 int res1 = 0 ;
30451 int val2 ;
30452 int ecode2 = 0 ;
30453 PyObject * obj0 = 0 ;
30454 PyObject * obj1 = 0 ;
30455 char * kwnames[] = {
30456 (char *) "self",(char *) "format", NULL
30457 };
30458
30459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
30460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30461 if (!SWIG_IsOK(res1)) {
30462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetType" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30463 }
30464 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30465 ecode2 = SWIG_AsVal_int(obj1, &val2);
30466 if (!SWIG_IsOK(ecode2)) {
30467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataFormat_SetType" "', expected argument " "2"" of type '" "wxDataFormatId""'");
30468 }
30469 arg2 = static_cast< wxDataFormatId >(val2);
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 (arg1)->SetType(arg2);
30473 wxPyEndAllowThreads(__tstate);
30474 if (PyErr_Occurred()) SWIG_fail;
30475 }
30476 resultobj = SWIG_Py_Void();
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 SWIGINTERN PyObject *_wrap_DataFormat_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30484 PyObject *resultobj = 0;
30485 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30486 wxDataFormatId result;
30487 void *argp1 = 0 ;
30488 int res1 = 0 ;
30489 PyObject *swig_obj[1] ;
30490
30491 if (!args) SWIG_fail;
30492 swig_obj[0] = args;
30493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30494 if (!SWIG_IsOK(res1)) {
30495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetType" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30496 }
30497 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
30501 wxPyEndAllowThreads(__tstate);
30502 if (PyErr_Occurred()) SWIG_fail;
30503 }
30504 resultobj = SWIG_From_int(static_cast< int >(result));
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 SWIGINTERN PyObject *_wrap_DataFormat_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30512 PyObject *resultobj = 0;
30513 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30514 wxString result;
30515 void *argp1 = 0 ;
30516 int res1 = 0 ;
30517 PyObject *swig_obj[1] ;
30518
30519 if (!args) SWIG_fail;
30520 swig_obj[0] = args;
30521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30522 if (!SWIG_IsOK(res1)) {
30523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_GetId" "', expected argument " "1"" of type '" "wxDataFormat const *""'");
30524 }
30525 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30526 {
30527 PyThreadState* __tstate = wxPyBeginAllowThreads();
30528 result = ((wxDataFormat const *)arg1)->GetId();
30529 wxPyEndAllowThreads(__tstate);
30530 if (PyErr_Occurred()) SWIG_fail;
30531 }
30532 {
30533 #if wxUSE_UNICODE
30534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30535 #else
30536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30537 #endif
30538 }
30539 return resultobj;
30540 fail:
30541 return NULL;
30542 }
30543
30544
30545 SWIGINTERN PyObject *_wrap_DataFormat_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30546 PyObject *resultobj = 0;
30547 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
30548 wxString *arg2 = 0 ;
30549 void *argp1 = 0 ;
30550 int res1 = 0 ;
30551 bool temp2 = false ;
30552 PyObject * obj0 = 0 ;
30553 PyObject * obj1 = 0 ;
30554 char * kwnames[] = {
30555 (char *) "self",(char *) "format", NULL
30556 };
30557
30558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataFormat, 0 | 0 );
30560 if (!SWIG_IsOK(res1)) {
30561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataFormat_SetId" "', expected argument " "1"" of type '" "wxDataFormat *""'");
30562 }
30563 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30564 {
30565 arg2 = wxString_in_helper(obj1);
30566 if (arg2 == NULL) SWIG_fail;
30567 temp2 = true;
30568 }
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 (arg1)->SetId((wxString const &)*arg2);
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 resultobj = SWIG_Py_Void();
30576 {
30577 if (temp2)
30578 delete arg2;
30579 }
30580 return resultobj;
30581 fail:
30582 {
30583 if (temp2)
30584 delete arg2;
30585 }
30586 return NULL;
30587 }
30588
30589
30590 SWIGINTERN PyObject *DataFormat_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30591 PyObject *obj;
30592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30593 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataFormat, SWIG_NewClientData(obj));
30594 return SWIG_Py_Void();
30595 }
30596
30597 SWIGINTERN PyObject *DataFormat_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30598 return SWIG_Python_InitShadowInstance(args);
30599 }
30600
30601 SWIGINTERN int FormatInvalid_set(PyObject *) {
30602 SWIG_Error(SWIG_AttributeError,"Variable FormatInvalid is read-only.");
30603 return 1;
30604 }
30605
30606
30607 SWIGINTERN PyObject *FormatInvalid_get(void) {
30608 PyObject *pyobj = 0;
30609
30610 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0 );
30611 return pyobj;
30612 }
30613
30614
30615 SWIGINTERN PyObject *_wrap_delete_DataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30616 PyObject *resultobj = 0;
30617 wxDataObject *arg1 = (wxDataObject *) 0 ;
30618 void *argp1 = 0 ;
30619 int res1 = 0 ;
30620 PyObject *swig_obj[1] ;
30621
30622 if (!args) SWIG_fail;
30623 swig_obj[0] = args;
30624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
30625 if (!SWIG_IsOK(res1)) {
30626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DataObject" "', expected argument " "1"" of type '" "wxDataObject *""'");
30627 }
30628 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30629 {
30630 PyThreadState* __tstate = wxPyBeginAllowThreads();
30631 delete arg1;
30632
30633 wxPyEndAllowThreads(__tstate);
30634 if (PyErr_Occurred()) SWIG_fail;
30635 }
30636 resultobj = SWIG_Py_Void();
30637 return resultobj;
30638 fail:
30639 return NULL;
30640 }
30641
30642
30643 SWIGINTERN PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30644 PyObject *resultobj = 0;
30645 wxDataObject *arg1 = (wxDataObject *) 0 ;
30646 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30647 SwigValueWrapper<wxDataFormat > result;
30648 void *argp1 = 0 ;
30649 int res1 = 0 ;
30650 int val2 ;
30651 int ecode2 = 0 ;
30652 PyObject * obj0 = 0 ;
30653 PyObject * obj1 = 0 ;
30654 char * kwnames[] = {
30655 (char *) "self",(char *) "dir", NULL
30656 };
30657
30658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) SWIG_fail;
30659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30660 if (!SWIG_IsOK(res1)) {
30661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30662 }
30663 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30664 if (obj1) {
30665 ecode2 = SWIG_AsVal_int(obj1, &val2);
30666 if (!SWIG_IsOK(ecode2)) {
30667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetPreferredFormat" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30668 }
30669 arg2 = static_cast< wxDataObject::Direction >(val2);
30670 }
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 result = ((wxDataObject const *)arg1)->GetPreferredFormat(arg2);
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_NewPointerObj((new wxDataFormat(static_cast< const wxDataFormat& >(result))), SWIGTYPE_p_wxDataFormat, SWIG_POINTER_OWN | 0 );
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_DataObject_GetFormatCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30685 PyObject *resultobj = 0;
30686 wxDataObject *arg1 = (wxDataObject *) 0 ;
30687 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30688 size_t result;
30689 void *argp1 = 0 ;
30690 int res1 = 0 ;
30691 int val2 ;
30692 int ecode2 = 0 ;
30693 PyObject * obj0 = 0 ;
30694 PyObject * obj1 = 0 ;
30695 char * kwnames[] = {
30696 (char *) "self",(char *) "dir", NULL
30697 };
30698
30699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) SWIG_fail;
30700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30701 if (!SWIG_IsOK(res1)) {
30702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetFormatCount" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30703 }
30704 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30705 if (obj1) {
30706 ecode2 = SWIG_AsVal_int(obj1, &val2);
30707 if (!SWIG_IsOK(ecode2)) {
30708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetFormatCount" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30709 }
30710 arg2 = static_cast< wxDataObject::Direction >(val2);
30711 }
30712 {
30713 PyThreadState* __tstate = wxPyBeginAllowThreads();
30714 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount(arg2);
30715 wxPyEndAllowThreads(__tstate);
30716 if (PyErr_Occurred()) SWIG_fail;
30717 }
30718 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30719 return resultobj;
30720 fail:
30721 return NULL;
30722 }
30723
30724
30725 SWIGINTERN PyObject *_wrap_DataObject_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30726 PyObject *resultobj = 0;
30727 wxDataObject *arg1 = (wxDataObject *) 0 ;
30728 wxDataFormat *arg2 = 0 ;
30729 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
30730 bool result;
30731 void *argp1 = 0 ;
30732 int res1 = 0 ;
30733 void *argp2 = 0 ;
30734 int res2 = 0 ;
30735 int val3 ;
30736 int ecode3 = 0 ;
30737 PyObject * obj0 = 0 ;
30738 PyObject * obj1 = 0 ;
30739 PyObject * obj2 = 0 ;
30740 char * kwnames[] = {
30741 (char *) "self",(char *) "format",(char *) "dir", NULL
30742 };
30743
30744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_IsSupported" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30748 }
30749 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30751 if (!SWIG_IsOK(res2)) {
30752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30753 }
30754 if (!argp2) {
30755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30756 }
30757 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30758 if (obj2) {
30759 ecode3 = SWIG_AsVal_int(obj2, &val3);
30760 if (!SWIG_IsOK(ecode3)) {
30761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObject_IsSupported" "', expected argument " "3"" of type '" "wxDataObject::Direction""'");
30762 }
30763 arg3 = static_cast< wxDataObject::Direction >(val3);
30764 }
30765 {
30766 PyThreadState* __tstate = wxPyBeginAllowThreads();
30767 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,arg3);
30768 wxPyEndAllowThreads(__tstate);
30769 if (PyErr_Occurred()) SWIG_fail;
30770 }
30771 {
30772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30773 }
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 SWIGINTERN PyObject *_wrap_DataObject_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj = 0;
30782 wxDataObject *arg1 = (wxDataObject *) 0 ;
30783 wxDataFormat *arg2 = 0 ;
30784 size_t result;
30785 void *argp1 = 0 ;
30786 int res1 = 0 ;
30787 void *argp2 = 0 ;
30788 int res2 = 0 ;
30789 PyObject * obj0 = 0 ;
30790 PyObject * obj1 = 0 ;
30791 char * kwnames[] = {
30792 (char *) "self",(char *) "format", NULL
30793 };
30794
30795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) SWIG_fail;
30796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30797 if (!SWIG_IsOK(res1)) {
30798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataSize" "', expected argument " "1"" of type '" "wxDataObject const *""'");
30799 }
30800 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30801 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30802 if (!SWIG_IsOK(res2)) {
30803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30804 }
30805 if (!argp2) {
30806 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataSize" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30807 }
30808 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30809 {
30810 PyThreadState* __tstate = wxPyBeginAllowThreads();
30811 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
30812 wxPyEndAllowThreads(__tstate);
30813 if (PyErr_Occurred()) SWIG_fail;
30814 }
30815 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
30816 return resultobj;
30817 fail:
30818 return NULL;
30819 }
30820
30821
30822 SWIGINTERN PyObject *_wrap_DataObject_GetAllFormats(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30823 PyObject *resultobj = 0;
30824 wxDataObject *arg1 = (wxDataObject *) 0 ;
30825 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
30826 PyObject *result = 0 ;
30827 void *argp1 = 0 ;
30828 int res1 = 0 ;
30829 int val2 ;
30830 int ecode2 = 0 ;
30831 PyObject * obj0 = 0 ;
30832 PyObject * obj1 = 0 ;
30833 char * kwnames[] = {
30834 (char *) "self",(char *) "dir", NULL
30835 };
30836
30837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) SWIG_fail;
30838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30839 if (!SWIG_IsOK(res1)) {
30840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetAllFormats" "', expected argument " "1"" of type '" "wxDataObject *""'");
30841 }
30842 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30843 if (obj1) {
30844 ecode2 = SWIG_AsVal_int(obj1, &val2);
30845 if (!SWIG_IsOK(ecode2)) {
30846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DataObject_GetAllFormats" "', expected argument " "2"" of type '" "wxDataObject::Direction""'");
30847 }
30848 arg2 = static_cast< wxDataObject::Direction >(val2);
30849 }
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 result = (PyObject *)wxDataObject_GetAllFormats(arg1,arg2);
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = result;
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 SWIGINTERN PyObject *_wrap_DataObject_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30864 PyObject *resultobj = 0;
30865 wxDataObject *arg1 = (wxDataObject *) 0 ;
30866 wxDataFormat *arg2 = 0 ;
30867 PyObject *result = 0 ;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 void *argp2 = 0 ;
30871 int res2 = 0 ;
30872 PyObject * obj0 = 0 ;
30873 PyObject * obj1 = 0 ;
30874 char * kwnames[] = {
30875 (char *) "self",(char *) "format", NULL
30876 };
30877
30878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) SWIG_fail;
30879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30880 if (!SWIG_IsOK(res1)) {
30881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_GetDataHere" "', expected argument " "1"" of type '" "wxDataObject *""'");
30882 }
30883 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30884 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30885 if (!SWIG_IsOK(res2)) {
30886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30887 }
30888 if (!argp2) {
30889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_GetDataHere" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30890 }
30891 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 resultobj = result;
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 SWIGINTERN PyObject *_wrap_DataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30906 PyObject *resultobj = 0;
30907 wxDataObject *arg1 = (wxDataObject *) 0 ;
30908 wxDataFormat *arg2 = 0 ;
30909 PyObject *arg3 = (PyObject *) 0 ;
30910 bool result;
30911 void *argp1 = 0 ;
30912 int res1 = 0 ;
30913 void *argp2 = 0 ;
30914 int res2 = 0 ;
30915 PyObject * obj0 = 0 ;
30916 PyObject * obj1 = 0 ;
30917 PyObject * obj2 = 0 ;
30918 char * kwnames[] = {
30919 (char *) "self",(char *) "format",(char *) "data", NULL
30920 };
30921
30922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObject, 0 | 0 );
30924 if (!SWIG_IsOK(res1)) {
30925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObject_SetData" "', expected argument " "1"" of type '" "wxDataObject *""'");
30926 }
30927 arg1 = reinterpret_cast< wxDataObject * >(argp1);
30928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
30929 if (!SWIG_IsOK(res2)) {
30930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30931 }
30932 if (!argp2) {
30933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObject_SetData" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
30934 }
30935 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
30936 arg3 = obj2;
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 {
30944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30945 }
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 SWIGINTERN PyObject *DataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30953 PyObject *obj;
30954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30955 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObject, SWIG_NewClientData(obj));
30956 return SWIG_Py_Void();
30957 }
30958
30959 SWIGINTERN PyObject *_wrap_new_DataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30960 PyObject *resultobj = 0;
30961 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
30962 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
30963 wxDataObjectSimple *result = 0 ;
30964 void *argp1 = 0 ;
30965 int res1 = 0 ;
30966 PyObject * obj0 = 0 ;
30967 char * kwnames[] = {
30968 (char *) "format", NULL
30969 };
30970
30971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) SWIG_fail;
30972 if (obj0) {
30973 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
30974 if (!SWIG_IsOK(res1)) {
30975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
30976 }
30977 if (!argp1) {
30978 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
30979 }
30980 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
30981 }
30982 {
30983 PyThreadState* __tstate = wxPyBeginAllowThreads();
30984 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
30985 wxPyEndAllowThreads(__tstate);
30986 if (PyErr_Occurred()) SWIG_fail;
30987 }
30988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_NEW | 0 );
30989 return resultobj;
30990 fail:
30991 return NULL;
30992 }
30993
30994
30995 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30996 PyObject *resultobj = 0;
30997 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
30998 wxDataFormat *result = 0 ;
30999 void *argp1 = 0 ;
31000 int res1 = 0 ;
31001 PyObject *swig_obj[1] ;
31002
31003 if (!args) SWIG_fail;
31004 swig_obj[0] = args;
31005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31006 if (!SWIG_IsOK(res1)) {
31007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31008 }
31009 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31010 {
31011 PyThreadState* __tstate = wxPyBeginAllowThreads();
31012 {
31013 wxDataFormat const &_result_ref = (arg1)->GetFormat();
31014 result = (wxDataFormat *) &_result_ref;
31015 }
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataFormat, 0 | 0 );
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31027 PyObject *resultobj = 0;
31028 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31029 wxDataFormat *arg2 = 0 ;
31030 void *argp1 = 0 ;
31031 int res1 = 0 ;
31032 void *argp2 = 0 ;
31033 int res2 = 0 ;
31034 PyObject * obj0 = 0 ;
31035 PyObject * obj1 = 0 ;
31036 char * kwnames[] = {
31037 (char *) "self",(char *) "format", NULL
31038 };
31039
31040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) SWIG_fail;
31041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31042 if (!SWIG_IsOK(res1)) {
31043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31044 }
31045 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31046 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
31047 if (!SWIG_IsOK(res2)) {
31048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31049 }
31050 if (!argp2) {
31051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DataObjectSimple_SetFormat" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
31052 }
31053 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
31054 {
31055 PyThreadState* __tstate = wxPyBeginAllowThreads();
31056 (arg1)->SetFormat((wxDataFormat const &)*arg2);
31057 wxPyEndAllowThreads(__tstate);
31058 if (PyErr_Occurred()) SWIG_fail;
31059 }
31060 resultobj = SWIG_Py_Void();
31061 return resultobj;
31062 fail:
31063 return NULL;
31064 }
31065
31066
31067 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31068 PyObject *resultobj = 0;
31069 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31070 size_t result;
31071 void *argp1 = 0 ;
31072 int res1 = 0 ;
31073 PyObject *swig_obj[1] ;
31074
31075 if (!args) SWIG_fail;
31076 swig_obj[0] = args;
31077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31078 if (!SWIG_IsOK(res1)) {
31079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataSize" "', expected argument " "1"" of type '" "wxDataObjectSimple const *""'");
31080 }
31081 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31082 {
31083 PyThreadState* __tstate = wxPyBeginAllowThreads();
31084 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31089 return resultobj;
31090 fail:
31091 return NULL;
31092 }
31093
31094
31095 SWIGINTERN PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31096 PyObject *resultobj = 0;
31097 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31098 PyObject *result = 0 ;
31099 void *argp1 = 0 ;
31100 int res1 = 0 ;
31101 PyObject *swig_obj[1] ;
31102
31103 if (!args) SWIG_fail;
31104 swig_obj[0] = args;
31105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31106 if (!SWIG_IsOK(res1)) {
31107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_GetDataHere" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31108 }
31109 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31110 {
31111 PyThreadState* __tstate = wxPyBeginAllowThreads();
31112 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
31113 wxPyEndAllowThreads(__tstate);
31114 if (PyErr_Occurred()) SWIG_fail;
31115 }
31116 resultobj = result;
31117 return resultobj;
31118 fail:
31119 return NULL;
31120 }
31121
31122
31123 SWIGINTERN PyObject *_wrap_DataObjectSimple_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31124 PyObject *resultobj = 0;
31125 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
31126 PyObject *arg2 = (PyObject *) 0 ;
31127 bool result;
31128 void *argp1 = 0 ;
31129 int res1 = 0 ;
31130 PyObject * obj0 = 0 ;
31131 PyObject * obj1 = 0 ;
31132 char * kwnames[] = {
31133 (char *) "self",(char *) "data", NULL
31134 };
31135
31136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
31137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectSimple, 0 | 0 );
31138 if (!SWIG_IsOK(res1)) {
31139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectSimple_SetData" "', expected argument " "1"" of type '" "wxDataObjectSimple *""'");
31140 }
31141 arg1 = reinterpret_cast< wxDataObjectSimple * >(argp1);
31142 arg2 = obj1;
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 {
31150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31151 }
31152 return resultobj;
31153 fail:
31154 return NULL;
31155 }
31156
31157
31158 SWIGINTERN PyObject *DataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31159 PyObject *obj;
31160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31161 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectSimple, SWIG_NewClientData(obj));
31162 return SWIG_Py_Void();
31163 }
31164
31165 SWIGINTERN PyObject *DataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31166 return SWIG_Python_InitShadowInstance(args);
31167 }
31168
31169 SWIGINTERN PyObject *_wrap_new_PyDataObjectSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31170 PyObject *resultobj = 0;
31171 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
31172 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
31173 wxPyDataObjectSimple *result = 0 ;
31174 void *argp1 = 0 ;
31175 int res1 = 0 ;
31176 PyObject * obj0 = 0 ;
31177 char * kwnames[] = {
31178 (char *) "format", NULL
31179 };
31180
31181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) SWIG_fail;
31182 if (obj0) {
31183 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31184 if (!SWIG_IsOK(res1)) {
31185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31186 }
31187 if (!argp1) {
31188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyDataObjectSimple" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31189 }
31190 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31191 }
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
31195 wxPyEndAllowThreads(__tstate);
31196 if (PyErr_Occurred()) SWIG_fail;
31197 }
31198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_NEW | 0 );
31199 return resultobj;
31200 fail:
31201 return NULL;
31202 }
31203
31204
31205 SWIGINTERN PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31206 PyObject *resultobj = 0;
31207 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
31208 PyObject *arg2 = (PyObject *) 0 ;
31209 PyObject *arg3 = (PyObject *) 0 ;
31210 void *argp1 = 0 ;
31211 int res1 = 0 ;
31212 PyObject * obj0 = 0 ;
31213 PyObject * obj1 = 0 ;
31214 PyObject * obj2 = 0 ;
31215 char * kwnames[] = {
31216 (char *) "self",(char *) "self",(char *) "_class", NULL
31217 };
31218
31219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDataObjectSimple, 0 | 0 );
31221 if (!SWIG_IsOK(res1)) {
31222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyDataObjectSimple__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDataObjectSimple *""'");
31223 }
31224 arg1 = reinterpret_cast< wxPyDataObjectSimple * >(argp1);
31225 arg2 = obj1;
31226 arg3 = obj2;
31227 {
31228 PyThreadState* __tstate = wxPyBeginAllowThreads();
31229 (arg1)->_setCallbackInfo(arg2,arg3);
31230 wxPyEndAllowThreads(__tstate);
31231 if (PyErr_Occurred()) SWIG_fail;
31232 }
31233 resultobj = SWIG_Py_Void();
31234 return resultobj;
31235 fail:
31236 return NULL;
31237 }
31238
31239
31240 SWIGINTERN PyObject *PyDataObjectSimple_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31241 PyObject *obj;
31242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31243 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDataObjectSimple, SWIG_NewClientData(obj));
31244 return SWIG_Py_Void();
31245 }
31246
31247 SWIGINTERN PyObject *PyDataObjectSimple_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31248 return SWIG_Python_InitShadowInstance(args);
31249 }
31250
31251 SWIGINTERN PyObject *_wrap_new_DataObjectComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31252 PyObject *resultobj = 0;
31253 wxDataObjectComposite *result = 0 ;
31254
31255 if (!SWIG_Python_UnpackTuple(args,"new_DataObjectComposite",0,0,0)) SWIG_fail;
31256 {
31257 PyThreadState* __tstate = wxPyBeginAllowThreads();
31258 result = (wxDataObjectComposite *)new wxDataObjectComposite();
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_NEW | 0 );
31263 return resultobj;
31264 fail:
31265 return NULL;
31266 }
31267
31268
31269 SWIGINTERN PyObject *_wrap_DataObjectComposite_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31270 PyObject *resultobj = 0;
31271 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
31272 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
31273 bool arg3 = (bool) false ;
31274 void *argp1 = 0 ;
31275 int res1 = 0 ;
31276 int res2 = 0 ;
31277 bool val3 ;
31278 int ecode3 = 0 ;
31279 PyObject * obj0 = 0 ;
31280 PyObject * obj1 = 0 ;
31281 PyObject * obj2 = 0 ;
31282 char * kwnames[] = {
31283 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
31284 };
31285
31286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDataObjectComposite, 0 | 0 );
31288 if (!SWIG_IsOK(res1)) {
31289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DataObjectComposite_Add" "', expected argument " "1"" of type '" "wxDataObjectComposite *""'");
31290 }
31291 arg1 = reinterpret_cast< wxDataObjectComposite * >(argp1);
31292 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_DISOWN | 0 );
31293 if (!SWIG_IsOK(res2)) {
31294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DataObjectComposite_Add" "', expected argument " "2"" of type '" "wxDataObjectSimple *""'");
31295 }
31296 if (obj2) {
31297 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31298 if (!SWIG_IsOK(ecode3)) {
31299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DataObjectComposite_Add" "', expected argument " "3"" of type '" "bool""'");
31300 }
31301 arg3 = static_cast< bool >(val3);
31302 }
31303 {
31304 PyThreadState* __tstate = wxPyBeginAllowThreads();
31305 (arg1)->Add(arg2,arg3);
31306 wxPyEndAllowThreads(__tstate);
31307 if (PyErr_Occurred()) SWIG_fail;
31308 }
31309 resultobj = SWIG_Py_Void();
31310 return resultobj;
31311 fail:
31312 return NULL;
31313 }
31314
31315
31316 SWIGINTERN PyObject *DataObjectComposite_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31317 PyObject *obj;
31318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31319 SWIG_TypeNewClientData(SWIGTYPE_p_wxDataObjectComposite, SWIG_NewClientData(obj));
31320 return SWIG_Py_Void();
31321 }
31322
31323 SWIGINTERN PyObject *DataObjectComposite_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31324 return SWIG_Python_InitShadowInstance(args);
31325 }
31326
31327 SWIGINTERN PyObject *_wrap_new_TextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31328 PyObject *resultobj = 0;
31329 wxString const &arg1_defvalue = wxPyEmptyString ;
31330 wxString *arg1 = (wxString *) &arg1_defvalue ;
31331 wxTextDataObject *result = 0 ;
31332 bool temp1 = false ;
31333 PyObject * obj0 = 0 ;
31334 char * kwnames[] = {
31335 (char *) "text", NULL
31336 };
31337
31338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) SWIG_fail;
31339 if (obj0) {
31340 {
31341 arg1 = wxString_in_helper(obj0);
31342 if (arg1 == NULL) SWIG_fail;
31343 temp1 = true;
31344 }
31345 }
31346 {
31347 PyThreadState* __tstate = wxPyBeginAllowThreads();
31348 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
31349 wxPyEndAllowThreads(__tstate);
31350 if (PyErr_Occurred()) SWIG_fail;
31351 }
31352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_NEW | 0 );
31353 {
31354 if (temp1)
31355 delete arg1;
31356 }
31357 return resultobj;
31358 fail:
31359 {
31360 if (temp1)
31361 delete arg1;
31362 }
31363 return NULL;
31364 }
31365
31366
31367 SWIGINTERN PyObject *_wrap_TextDataObject_GetTextLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31368 PyObject *resultobj = 0;
31369 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31370 size_t result;
31371 void *argp1 = 0 ;
31372 int res1 = 0 ;
31373 PyObject *swig_obj[1] ;
31374
31375 if (!args) SWIG_fail;
31376 swig_obj[0] = args;
31377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31378 if (!SWIG_IsOK(res1)) {
31379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetTextLength" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31380 }
31381 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 result = (size_t)(arg1)->GetTextLength();
31385 wxPyEndAllowThreads(__tstate);
31386 if (PyErr_Occurred()) SWIG_fail;
31387 }
31388 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
31389 return resultobj;
31390 fail:
31391 return NULL;
31392 }
31393
31394
31395 SWIGINTERN PyObject *_wrap_TextDataObject_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31396 PyObject *resultobj = 0;
31397 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31398 wxString result;
31399 void *argp1 = 0 ;
31400 int res1 = 0 ;
31401 PyObject *swig_obj[1] ;
31402
31403 if (!args) SWIG_fail;
31404 swig_obj[0] = args;
31405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31406 if (!SWIG_IsOK(res1)) {
31407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_GetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31408 }
31409 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 result = (arg1)->GetText();
31413 wxPyEndAllowThreads(__tstate);
31414 if (PyErr_Occurred()) SWIG_fail;
31415 }
31416 {
31417 #if wxUSE_UNICODE
31418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31419 #else
31420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31421 #endif
31422 }
31423 return resultobj;
31424 fail:
31425 return NULL;
31426 }
31427
31428
31429 SWIGINTERN PyObject *_wrap_TextDataObject_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31430 PyObject *resultobj = 0;
31431 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
31432 wxString *arg2 = 0 ;
31433 void *argp1 = 0 ;
31434 int res1 = 0 ;
31435 bool temp2 = false ;
31436 PyObject * obj0 = 0 ;
31437 PyObject * obj1 = 0 ;
31438 char * kwnames[] = {
31439 (char *) "self",(char *) "text", NULL
31440 };
31441
31442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
31443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextDataObject, 0 | 0 );
31444 if (!SWIG_IsOK(res1)) {
31445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDataObject_SetText" "', expected argument " "1"" of type '" "wxTextDataObject *""'");
31446 }
31447 arg1 = reinterpret_cast< wxTextDataObject * >(argp1);
31448 {
31449 arg2 = wxString_in_helper(obj1);
31450 if (arg2 == NULL) SWIG_fail;
31451 temp2 = true;
31452 }
31453 {
31454 PyThreadState* __tstate = wxPyBeginAllowThreads();
31455 (arg1)->SetText((wxString const &)*arg2);
31456 wxPyEndAllowThreads(__tstate);
31457 if (PyErr_Occurred()) SWIG_fail;
31458 }
31459 resultobj = SWIG_Py_Void();
31460 {
31461 if (temp2)
31462 delete arg2;
31463 }
31464 return resultobj;
31465 fail:
31466 {
31467 if (temp2)
31468 delete arg2;
31469 }
31470 return NULL;
31471 }
31472
31473
31474 SWIGINTERN PyObject *TextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31475 PyObject *obj;
31476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31477 SWIG_TypeNewClientData(SWIGTYPE_p_wxTextDataObject, SWIG_NewClientData(obj));
31478 return SWIG_Py_Void();
31479 }
31480
31481 SWIGINTERN PyObject *TextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 return SWIG_Python_InitShadowInstance(args);
31483 }
31484
31485 SWIGINTERN PyObject *_wrap_new_PyTextDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31486 PyObject *resultobj = 0;
31487 wxString const &arg1_defvalue = wxPyEmptyString ;
31488 wxString *arg1 = (wxString *) &arg1_defvalue ;
31489 wxPyTextDataObject *result = 0 ;
31490 bool temp1 = false ;
31491 PyObject * obj0 = 0 ;
31492 char * kwnames[] = {
31493 (char *) "text", NULL
31494 };
31495
31496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) SWIG_fail;
31497 if (obj0) {
31498 {
31499 arg1 = wxString_in_helper(obj0);
31500 if (arg1 == NULL) SWIG_fail;
31501 temp1 = true;
31502 }
31503 }
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
31507 wxPyEndAllowThreads(__tstate);
31508 if (PyErr_Occurred()) SWIG_fail;
31509 }
31510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_NEW | 0 );
31511 {
31512 if (temp1)
31513 delete arg1;
31514 }
31515 return resultobj;
31516 fail:
31517 {
31518 if (temp1)
31519 delete arg1;
31520 }
31521 return NULL;
31522 }
31523
31524
31525 SWIGINTERN PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31526 PyObject *resultobj = 0;
31527 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
31528 PyObject *arg2 = (PyObject *) 0 ;
31529 PyObject *arg3 = (PyObject *) 0 ;
31530 void *argp1 = 0 ;
31531 int res1 = 0 ;
31532 PyObject * obj0 = 0 ;
31533 PyObject * obj1 = 0 ;
31534 PyObject * obj2 = 0 ;
31535 char * kwnames[] = {
31536 (char *) "self",(char *) "self",(char *) "_class", NULL
31537 };
31538
31539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDataObject, 0 | 0 );
31541 if (!SWIG_IsOK(res1)) {
31542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTextDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDataObject *""'");
31543 }
31544 arg1 = reinterpret_cast< wxPyTextDataObject * >(argp1);
31545 arg2 = obj1;
31546 arg3 = obj2;
31547 {
31548 PyThreadState* __tstate = wxPyBeginAllowThreads();
31549 (arg1)->_setCallbackInfo(arg2,arg3);
31550 wxPyEndAllowThreads(__tstate);
31551 if (PyErr_Occurred()) SWIG_fail;
31552 }
31553 resultobj = SWIG_Py_Void();
31554 return resultobj;
31555 fail:
31556 return NULL;
31557 }
31558
31559
31560 SWIGINTERN PyObject *PyTextDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31561 PyObject *obj;
31562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31563 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDataObject, SWIG_NewClientData(obj));
31564 return SWIG_Py_Void();
31565 }
31566
31567 SWIGINTERN PyObject *PyTextDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31568 return SWIG_Python_InitShadowInstance(args);
31569 }
31570
31571 SWIGINTERN PyObject *_wrap_new_BitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31572 PyObject *resultobj = 0;
31573 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31574 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31575 wxBitmapDataObject *result = 0 ;
31576 void *argp1 = 0 ;
31577 int res1 = 0 ;
31578 PyObject * obj0 = 0 ;
31579 char * kwnames[] = {
31580 (char *) "bitmap", NULL
31581 };
31582
31583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) SWIG_fail;
31584 if (obj0) {
31585 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31586 if (!SWIG_IsOK(res1)) {
31587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31588 }
31589 if (!argp1) {
31590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31591 }
31592 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31593 }
31594 {
31595 PyThreadState* __tstate = wxPyBeginAllowThreads();
31596 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_NEW | 0 );
31601 return resultobj;
31602 fail:
31603 return NULL;
31604 }
31605
31606
31607 SWIGINTERN PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31608 PyObject *resultobj = 0;
31609 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31610 wxBitmap result;
31611 void *argp1 = 0 ;
31612 int res1 = 0 ;
31613 PyObject *swig_obj[1] ;
31614
31615 if (!args) SWIG_fail;
31616 swig_obj[0] = args;
31617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31618 if (!SWIG_IsOK(res1)) {
31619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_GetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject const *""'");
31620 }
31621 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31622 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
31625 wxPyEndAllowThreads(__tstate);
31626 if (PyErr_Occurred()) SWIG_fail;
31627 }
31628 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
31629 return resultobj;
31630 fail:
31631 return NULL;
31632 }
31633
31634
31635 SWIGINTERN PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31636 PyObject *resultobj = 0;
31637 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
31638 wxBitmap *arg2 = 0 ;
31639 void *argp1 = 0 ;
31640 int res1 = 0 ;
31641 void *argp2 = 0 ;
31642 int res2 = 0 ;
31643 PyObject * obj0 = 0 ;
31644 PyObject * obj1 = 0 ;
31645 char * kwnames[] = {
31646 (char *) "self",(char *) "bitmap", NULL
31647 };
31648
31649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
31650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBitmapDataObject, 0 | 0 );
31651 if (!SWIG_IsOK(res1)) {
31652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "1"" of type '" "wxBitmapDataObject *""'");
31653 }
31654 arg1 = reinterpret_cast< wxBitmapDataObject * >(argp1);
31655 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
31656 if (!SWIG_IsOK(res2)) {
31657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31658 }
31659 if (!argp2) {
31660 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BitmapDataObject_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
31661 }
31662 arg2 = reinterpret_cast< wxBitmap * >(argp2);
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 (arg1)->SetBitmap((wxBitmap const &)*arg2);
31666 wxPyEndAllowThreads(__tstate);
31667 if (PyErr_Occurred()) SWIG_fail;
31668 }
31669 resultobj = SWIG_Py_Void();
31670 return resultobj;
31671 fail:
31672 return NULL;
31673 }
31674
31675
31676 SWIGINTERN PyObject *BitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31677 PyObject *obj;
31678 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31679 SWIG_TypeNewClientData(SWIGTYPE_p_wxBitmapDataObject, SWIG_NewClientData(obj));
31680 return SWIG_Py_Void();
31681 }
31682
31683 SWIGINTERN PyObject *BitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31684 return SWIG_Python_InitShadowInstance(args);
31685 }
31686
31687 SWIGINTERN PyObject *_wrap_new_PyBitmapDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31688 PyObject *resultobj = 0;
31689 wxBitmap const &arg1_defvalue = wxNullBitmap ;
31690 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
31691 wxPyBitmapDataObject *result = 0 ;
31692 void *argp1 = 0 ;
31693 int res1 = 0 ;
31694 PyObject * obj0 = 0 ;
31695 char * kwnames[] = {
31696 (char *) "bitmap", NULL
31697 };
31698
31699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) SWIG_fail;
31700 if (obj0) {
31701 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
31702 if (!SWIG_IsOK(res1)) {
31703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31704 }
31705 if (!argp1) {
31706 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PyBitmapDataObject" "', expected argument " "1"" of type '" "wxBitmap const &""'");
31707 }
31708 arg1 = reinterpret_cast< wxBitmap * >(argp1);
31709 }
31710 {
31711 PyThreadState* __tstate = wxPyBeginAllowThreads();
31712 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
31713 wxPyEndAllowThreads(__tstate);
31714 if (PyErr_Occurred()) SWIG_fail;
31715 }
31716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_NEW | 0 );
31717 return resultobj;
31718 fail:
31719 return NULL;
31720 }
31721
31722
31723 SWIGINTERN PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31724 PyObject *resultobj = 0;
31725 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
31726 PyObject *arg2 = (PyObject *) 0 ;
31727 PyObject *arg3 = (PyObject *) 0 ;
31728 void *argp1 = 0 ;
31729 int res1 = 0 ;
31730 PyObject * obj0 = 0 ;
31731 PyObject * obj1 = 0 ;
31732 PyObject * obj2 = 0 ;
31733 char * kwnames[] = {
31734 (char *) "self",(char *) "self",(char *) "_class", NULL
31735 };
31736
31737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyBitmapDataObject, 0 | 0 );
31739 if (!SWIG_IsOK(res1)) {
31740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyBitmapDataObject__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyBitmapDataObject *""'");
31741 }
31742 arg1 = reinterpret_cast< wxPyBitmapDataObject * >(argp1);
31743 arg2 = obj1;
31744 arg3 = obj2;
31745 {
31746 PyThreadState* __tstate = wxPyBeginAllowThreads();
31747 (arg1)->_setCallbackInfo(arg2,arg3);
31748 wxPyEndAllowThreads(__tstate);
31749 if (PyErr_Occurred()) SWIG_fail;
31750 }
31751 resultobj = SWIG_Py_Void();
31752 return resultobj;
31753 fail:
31754 return NULL;
31755 }
31756
31757
31758 SWIGINTERN PyObject *PyBitmapDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31759 PyObject *obj;
31760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31761 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyBitmapDataObject, SWIG_NewClientData(obj));
31762 return SWIG_Py_Void();
31763 }
31764
31765 SWIGINTERN PyObject *PyBitmapDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31766 return SWIG_Python_InitShadowInstance(args);
31767 }
31768
31769 SWIGINTERN PyObject *_wrap_new_FileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31770 PyObject *resultobj = 0;
31771 wxFileDataObject *result = 0 ;
31772
31773 if (!SWIG_Python_UnpackTuple(args,"new_FileDataObject",0,0,0)) SWIG_fail;
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 result = (wxFileDataObject *)new wxFileDataObject();
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_NEW | 0 );
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_FileDataObject_GetFilenames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31788 PyObject *resultobj = 0;
31789 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31790 wxArrayString *result = 0 ;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 PyObject *swig_obj[1] ;
31794
31795 if (!args) SWIG_fail;
31796 swig_obj[0] = args;
31797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31798 if (!SWIG_IsOK(res1)) {
31799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_GetFilenames" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31800 }
31801 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 {
31805 wxArrayString const &_result_ref = (arg1)->GetFilenames();
31806 result = (wxArrayString *) &_result_ref;
31807 }
31808 wxPyEndAllowThreads(__tstate);
31809 if (PyErr_Occurred()) SWIG_fail;
31810 }
31811 {
31812 resultobj = wxArrayString2PyList_helper(*result);
31813 }
31814 return resultobj;
31815 fail:
31816 return NULL;
31817 }
31818
31819
31820 SWIGINTERN PyObject *_wrap_FileDataObject_AddFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31821 PyObject *resultobj = 0;
31822 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
31823 wxString *arg2 = 0 ;
31824 void *argp1 = 0 ;
31825 int res1 = 0 ;
31826 bool temp2 = false ;
31827 PyObject * obj0 = 0 ;
31828 PyObject * obj1 = 0 ;
31829 char * kwnames[] = {
31830 (char *) "self",(char *) "filename", NULL
31831 };
31832
31833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) SWIG_fail;
31834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileDataObject, 0 | 0 );
31835 if (!SWIG_IsOK(res1)) {
31836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDataObject_AddFile" "', expected argument " "1"" of type '" "wxFileDataObject *""'");
31837 }
31838 arg1 = reinterpret_cast< wxFileDataObject * >(argp1);
31839 {
31840 arg2 = wxString_in_helper(obj1);
31841 if (arg2 == NULL) SWIG_fail;
31842 temp2 = true;
31843 }
31844 {
31845 PyThreadState* __tstate = wxPyBeginAllowThreads();
31846 (arg1)->AddFile((wxString const &)*arg2);
31847 wxPyEndAllowThreads(__tstate);
31848 if (PyErr_Occurred()) SWIG_fail;
31849 }
31850 resultobj = SWIG_Py_Void();
31851 {
31852 if (temp2)
31853 delete arg2;
31854 }
31855 return resultobj;
31856 fail:
31857 {
31858 if (temp2)
31859 delete arg2;
31860 }
31861 return NULL;
31862 }
31863
31864
31865 SWIGINTERN PyObject *FileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31866 PyObject *obj;
31867 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31868 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileDataObject, SWIG_NewClientData(obj));
31869 return SWIG_Py_Void();
31870 }
31871
31872 SWIGINTERN PyObject *FileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31873 return SWIG_Python_InitShadowInstance(args);
31874 }
31875
31876 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31877 PyObject *resultobj = 0;
31878 wxDataFormat *arg1 = 0 ;
31879 wxCustomDataObject *result = 0 ;
31880 void *argp1 = 0 ;
31881 int res1 = 0 ;
31882
31883 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxDataFormat, 0 | 0);
31885 if (!SWIG_IsOK(res1)) {
31886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31887 }
31888 if (!argp1) {
31889 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CustomDataObject" "', expected argument " "1"" of type '" "wxDataFormat const &""'");
31890 }
31891 arg1 = reinterpret_cast< wxDataFormat * >(argp1);
31892 {
31893 PyThreadState* __tstate = wxPyBeginAllowThreads();
31894 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
31895 wxPyEndAllowThreads(__tstate);
31896 if (PyErr_Occurred()) SWIG_fail;
31897 }
31898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31899 return resultobj;
31900 fail:
31901 return NULL;
31902 }
31903
31904
31905 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
31906 PyObject *resultobj = 0;
31907 wxString *arg1 = 0 ;
31908 wxCustomDataObject *result = 0 ;
31909 bool temp1 = false ;
31910
31911 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
31912 {
31913 arg1 = wxString_in_helper(swig_obj[0]);
31914 if (arg1 == NULL) SWIG_fail;
31915 temp1 = true;
31916 }
31917 {
31918 PyThreadState* __tstate = wxPyBeginAllowThreads();
31919 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
31920 wxPyEndAllowThreads(__tstate);
31921 if (PyErr_Occurred()) SWIG_fail;
31922 }
31923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31924 {
31925 if (temp1)
31926 delete arg1;
31927 }
31928 return resultobj;
31929 fail:
31930 {
31931 if (temp1)
31932 delete arg1;
31933 }
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
31939 PyObject *resultobj = 0;
31940 wxCustomDataObject *result = 0 ;
31941
31942 if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
31943 {
31944 PyThreadState* __tstate = wxPyBeginAllowThreads();
31945 result = (wxCustomDataObject *)new wxCustomDataObject();
31946 wxPyEndAllowThreads(__tstate);
31947 if (PyErr_Occurred()) SWIG_fail;
31948 }
31949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_NEW | 0 );
31950 return resultobj;
31951 fail:
31952 return NULL;
31953 }
31954
31955
31956 SWIGINTERN PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
31957 int argc;
31958 PyObject *argv[2];
31959
31960 if (!(argc = SWIG_Python_UnpackTuple(args,"new_CustomDataObject",0,1,argv))) SWIG_fail;
31961 --argc;
31962 if (argc == 0) {
31963 return _wrap_new_CustomDataObject__SWIG_2(self, argc, argv);
31964 }
31965 if (argc == 1) {
31966 int _v = 0;
31967 {
31968 {
31969 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
31970 }
31971 }
31972 if (!_v) goto check_2;
31973 return _wrap_new_CustomDataObject__SWIG_1(self, argc, argv);
31974 }
31975 check_2:
31976
31977 if (argc == 1) {
31978 return _wrap_new_CustomDataObject__SWIG_0(self, argc, argv);
31979 }
31980
31981 fail:
31982 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
31983 return NULL;
31984 }
31985
31986
31987 SWIGINTERN PyObject *_wrap_CustomDataObject_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31988 PyObject *resultobj = 0;
31989 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
31990 PyObject *arg2 = (PyObject *) 0 ;
31991 bool result;
31992 void *argp1 = 0 ;
31993 int res1 = 0 ;
31994 PyObject * obj0 = 0 ;
31995 PyObject * obj1 = 0 ;
31996 char * kwnames[] = {
31997 (char *) "self",(char *) "data", NULL
31998 };
31999
32000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32002 if (!SWIG_IsOK(res1)) {
32003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_SetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32004 }
32005 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32006 arg2 = obj1;
32007 {
32008 PyThreadState* __tstate = wxPyBeginAllowThreads();
32009 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
32010 wxPyEndAllowThreads(__tstate);
32011 if (PyErr_Occurred()) SWIG_fail;
32012 }
32013 {
32014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32015 }
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 SWIGINTERN PyObject *_wrap_CustomDataObject_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32023 PyObject *resultobj = 0;
32024 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32025 size_t result;
32026 void *argp1 = 0 ;
32027 int res1 = 0 ;
32028 PyObject *swig_obj[1] ;
32029
32030 if (!args) SWIG_fail;
32031 swig_obj[0] = args;
32032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32033 if (!SWIG_IsOK(res1)) {
32034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetSize" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32035 }
32036 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32037 {
32038 PyThreadState* __tstate = wxPyBeginAllowThreads();
32039 result = (size_t)(arg1)->GetSize();
32040 wxPyEndAllowThreads(__tstate);
32041 if (PyErr_Occurred()) SWIG_fail;
32042 }
32043 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
32044 return resultobj;
32045 fail:
32046 return NULL;
32047 }
32048
32049
32050 SWIGINTERN PyObject *_wrap_CustomDataObject_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32051 PyObject *resultobj = 0;
32052 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
32053 PyObject *result = 0 ;
32054 void *argp1 = 0 ;
32055 int res1 = 0 ;
32056 PyObject *swig_obj[1] ;
32057
32058 if (!args) SWIG_fail;
32059 swig_obj[0] = args;
32060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCustomDataObject, 0 | 0 );
32061 if (!SWIG_IsOK(res1)) {
32062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CustomDataObject_GetData" "', expected argument " "1"" of type '" "wxCustomDataObject *""'");
32063 }
32064 arg1 = reinterpret_cast< wxCustomDataObject * >(argp1);
32065 {
32066 PyThreadState* __tstate = wxPyBeginAllowThreads();
32067 result = (PyObject *)wxCustomDataObject_GetData(arg1);
32068 wxPyEndAllowThreads(__tstate);
32069 if (PyErr_Occurred()) SWIG_fail;
32070 }
32071 resultobj = result;
32072 return resultobj;
32073 fail:
32074 return NULL;
32075 }
32076
32077
32078 SWIGINTERN PyObject *CustomDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32079 PyObject *obj;
32080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32081 SWIG_TypeNewClientData(SWIGTYPE_p_wxCustomDataObject, SWIG_NewClientData(obj));
32082 return SWIG_Py_Void();
32083 }
32084
32085 SWIGINTERN PyObject *CustomDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32086 return SWIG_Python_InitShadowInstance(args);
32087 }
32088
32089 SWIGINTERN PyObject *_wrap_new_URLDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32090 PyObject *resultobj = 0;
32091 wxURLDataObject *result = 0 ;
32092
32093 if (!SWIG_Python_UnpackTuple(args,"new_URLDataObject",0,0,0)) SWIG_fail;
32094 {
32095 PyThreadState* __tstate = wxPyBeginAllowThreads();
32096 result = (wxURLDataObject *)new wxURLDataObject();
32097 wxPyEndAllowThreads(__tstate);
32098 if (PyErr_Occurred()) SWIG_fail;
32099 }
32100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_NEW | 0 );
32101 return resultobj;
32102 fail:
32103 return NULL;
32104 }
32105
32106
32107 SWIGINTERN PyObject *_wrap_URLDataObject_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32108 PyObject *resultobj = 0;
32109 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32110 wxString result;
32111 void *argp1 = 0 ;
32112 int res1 = 0 ;
32113 PyObject *swig_obj[1] ;
32114
32115 if (!args) SWIG_fail;
32116 swig_obj[0] = args;
32117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32118 if (!SWIG_IsOK(res1)) {
32119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_GetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32120 }
32121 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32122 {
32123 PyThreadState* __tstate = wxPyBeginAllowThreads();
32124 result = (arg1)->GetURL();
32125 wxPyEndAllowThreads(__tstate);
32126 if (PyErr_Occurred()) SWIG_fail;
32127 }
32128 {
32129 #if wxUSE_UNICODE
32130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32131 #else
32132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32133 #endif
32134 }
32135 return resultobj;
32136 fail:
32137 return NULL;
32138 }
32139
32140
32141 SWIGINTERN PyObject *_wrap_URLDataObject_SetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32142 PyObject *resultobj = 0;
32143 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
32144 wxString *arg2 = 0 ;
32145 void *argp1 = 0 ;
32146 int res1 = 0 ;
32147 bool temp2 = false ;
32148 PyObject * obj0 = 0 ;
32149 PyObject * obj1 = 0 ;
32150 char * kwnames[] = {
32151 (char *) "self",(char *) "url", NULL
32152 };
32153
32154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) SWIG_fail;
32155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxURLDataObject, 0 | 0 );
32156 if (!SWIG_IsOK(res1)) {
32157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "URLDataObject_SetURL" "', expected argument " "1"" of type '" "wxURLDataObject *""'");
32158 }
32159 arg1 = reinterpret_cast< wxURLDataObject * >(argp1);
32160 {
32161 arg2 = wxString_in_helper(obj1);
32162 if (arg2 == NULL) SWIG_fail;
32163 temp2 = true;
32164 }
32165 {
32166 PyThreadState* __tstate = wxPyBeginAllowThreads();
32167 (arg1)->SetURL((wxString const &)*arg2);
32168 wxPyEndAllowThreads(__tstate);
32169 if (PyErr_Occurred()) SWIG_fail;
32170 }
32171 resultobj = SWIG_Py_Void();
32172 {
32173 if (temp2)
32174 delete arg2;
32175 }
32176 return resultobj;
32177 fail:
32178 {
32179 if (temp2)
32180 delete arg2;
32181 }
32182 return NULL;
32183 }
32184
32185
32186 SWIGINTERN PyObject *URLDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32187 PyObject *obj;
32188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32189 SWIG_TypeNewClientData(SWIGTYPE_p_wxURLDataObject, SWIG_NewClientData(obj));
32190 return SWIG_Py_Void();
32191 }
32192
32193 SWIGINTERN PyObject *URLDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32194 return SWIG_Python_InitShadowInstance(args);
32195 }
32196
32197 SWIGINTERN PyObject *_wrap_new_MetafileDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32198 PyObject *resultobj = 0;
32199 wxMetafileDataObject *result = 0 ;
32200
32201 if (!SWIG_Python_UnpackTuple(args,"new_MetafileDataObject",0,0,0)) SWIG_fail;
32202 {
32203 PyThreadState* __tstate = wxPyBeginAllowThreads();
32204 result = (wxMetafileDataObject *)new wxMetafileDataObject();
32205 wxPyEndAllowThreads(__tstate);
32206 if (PyErr_Occurred()) SWIG_fail;
32207 }
32208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_NEW | 0 );
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32216 PyObject *resultobj = 0;
32217 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32218 wxMetafile *arg2 = 0 ;
32219 void *argp1 = 0 ;
32220 int res1 = 0 ;
32221 void *argp2 = 0 ;
32222 int res2 = 0 ;
32223 PyObject * obj0 = 0 ;
32224 PyObject * obj1 = 0 ;
32225 char * kwnames[] = {
32226 (char *) "self",(char *) "metafile", NULL
32227 };
32228
32229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) SWIG_fail;
32230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32231 if (!SWIG_IsOK(res1)) {
32232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject *""'");
32233 }
32234 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxMetafile, 0 | 0);
32236 if (!SWIG_IsOK(res2)) {
32237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32238 }
32239 if (!argp2) {
32240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MetafileDataObject_SetMetafile" "', expected argument " "2"" of type '" "wxMetafile const &""'");
32241 }
32242 arg2 = reinterpret_cast< wxMetafile * >(argp2);
32243 {
32244 PyThreadState* __tstate = wxPyBeginAllowThreads();
32245 (arg1)->SetMetafile((wxMetafile const &)*arg2);
32246 wxPyEndAllowThreads(__tstate);
32247 if (PyErr_Occurred()) SWIG_fail;
32248 }
32249 resultobj = SWIG_Py_Void();
32250 return resultobj;
32251 fail:
32252 return NULL;
32253 }
32254
32255
32256 SWIGINTERN PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32257 PyObject *resultobj = 0;
32258 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
32259 wxMetafile result;
32260 void *argp1 = 0 ;
32261 int res1 = 0 ;
32262 PyObject *swig_obj[1] ;
32263
32264 if (!args) SWIG_fail;
32265 swig_obj[0] = args;
32266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMetafileDataObject, 0 | 0 );
32267 if (!SWIG_IsOK(res1)) {
32268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MetafileDataObject_GetMetafile" "', expected argument " "1"" of type '" "wxMetafileDataObject const *""'");
32269 }
32270 arg1 = reinterpret_cast< wxMetafileDataObject * >(argp1);
32271 {
32272 PyThreadState* __tstate = wxPyBeginAllowThreads();
32273 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
32274 wxPyEndAllowThreads(__tstate);
32275 if (PyErr_Occurred()) SWIG_fail;
32276 }
32277 resultobj = SWIG_NewPointerObj((new wxMetafile(static_cast< const wxMetafile& >(result))), SWIGTYPE_p_wxMetafile, SWIG_POINTER_OWN | 0 );
32278 return resultobj;
32279 fail:
32280 return NULL;
32281 }
32282
32283
32284 SWIGINTERN PyObject *MetafileDataObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32285 PyObject *obj;
32286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32287 SWIG_TypeNewClientData(SWIGTYPE_p_wxMetafileDataObject, SWIG_NewClientData(obj));
32288 return SWIG_Py_Void();
32289 }
32290
32291 SWIGINTERN PyObject *MetafileDataObject_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32292 return SWIG_Python_InitShadowInstance(args);
32293 }
32294
32295 SWIGINTERN PyObject *_wrap_IsDragResultOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32296 PyObject *resultobj = 0;
32297 wxDragResult arg1 ;
32298 bool result;
32299 int val1 ;
32300 int ecode1 = 0 ;
32301 PyObject * obj0 = 0 ;
32302 char * kwnames[] = {
32303 (char *) "res", NULL
32304 };
32305
32306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) SWIG_fail;
32307 ecode1 = SWIG_AsVal_int(obj0, &val1);
32308 if (!SWIG_IsOK(ecode1)) {
32309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDragResultOk" "', expected argument " "1"" of type '" "wxDragResult""'");
32310 }
32311 arg1 = static_cast< wxDragResult >(val1);
32312 {
32313 PyThreadState* __tstate = wxPyBeginAllowThreads();
32314 result = (bool)wxIsDragResultOk(arg1);
32315 wxPyEndAllowThreads(__tstate);
32316 if (PyErr_Occurred()) SWIG_fail;
32317 }
32318 {
32319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32320 }
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 SWIGINTERN PyObject *_wrap_new_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32328 PyObject *resultobj = 0;
32329 wxWindow *arg1 = (wxWindow *) 0 ;
32330 wxCursor const &arg2_defvalue = wxNullCursor ;
32331 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
32332 wxCursor const &arg3_defvalue = wxNullCursor ;
32333 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
32334 wxCursor const &arg4_defvalue = wxNullCursor ;
32335 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
32336 wxPyDropSource *result = 0 ;
32337 void *argp1 = 0 ;
32338 int res1 = 0 ;
32339 void *argp2 = 0 ;
32340 int res2 = 0 ;
32341 void *argp3 = 0 ;
32342 int res3 = 0 ;
32343 void *argp4 = 0 ;
32344 int res4 = 0 ;
32345 PyObject * obj0 = 0 ;
32346 PyObject * obj1 = 0 ;
32347 PyObject * obj2 = 0 ;
32348 PyObject * obj3 = 0 ;
32349 char * kwnames[] = {
32350 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
32351 };
32352
32353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32355 if (!SWIG_IsOK(res1)) {
32356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropSource" "', expected argument " "1"" of type '" "wxWindow *""'");
32357 }
32358 arg1 = reinterpret_cast< wxWindow * >(argp1);
32359 if (obj1) {
32360 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
32361 if (!SWIG_IsOK(res2)) {
32362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32363 }
32364 if (!argp2) {
32365 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "2"" of type '" "wxCursor const &""'");
32366 }
32367 arg2 = reinterpret_cast< wxCursor * >(argp2);
32368 }
32369 if (obj2) {
32370 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32371 if (!SWIG_IsOK(res3)) {
32372 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32373 }
32374 if (!argp3) {
32375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "3"" of type '" "wxCursor const &""'");
32376 }
32377 arg3 = reinterpret_cast< wxCursor * >(argp3);
32378 }
32379 if (obj3) {
32380 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxCursor, 0 | 0);
32381 if (!SWIG_IsOK(res4)) {
32382 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32383 }
32384 if (!argp4) {
32385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DropSource" "', expected argument " "4"" of type '" "wxCursor const &""'");
32386 }
32387 arg4 = reinterpret_cast< wxCursor * >(argp4);
32388 }
32389 {
32390 PyThreadState* __tstate = wxPyBeginAllowThreads();
32391 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
32392 wxPyEndAllowThreads(__tstate);
32393 if (PyErr_Occurred()) SWIG_fail;
32394 }
32395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_NEW | 0 );
32396 return resultobj;
32397 fail:
32398 return NULL;
32399 }
32400
32401
32402 SWIGINTERN PyObject *_wrap_DropSource__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32403 PyObject *resultobj = 0;
32404 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32405 PyObject *arg2 = (PyObject *) 0 ;
32406 PyObject *arg3 = (PyObject *) 0 ;
32407 int arg4 ;
32408 void *argp1 = 0 ;
32409 int res1 = 0 ;
32410 int val4 ;
32411 int ecode4 = 0 ;
32412 PyObject * obj0 = 0 ;
32413 PyObject * obj1 = 0 ;
32414 PyObject * obj2 = 0 ;
32415 PyObject * obj3 = 0 ;
32416 char * kwnames[] = {
32417 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32418 };
32419
32420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32422 if (!SWIG_IsOK(res1)) {
32423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32424 }
32425 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32426 arg2 = obj1;
32427 arg3 = obj2;
32428 ecode4 = SWIG_AsVal_int(obj3, &val4);
32429 if (!SWIG_IsOK(ecode4)) {
32430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropSource__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
32431 }
32432 arg4 = static_cast< int >(val4);
32433 {
32434 PyThreadState* __tstate = wxPyBeginAllowThreads();
32435 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32436 wxPyEndAllowThreads(__tstate);
32437 if (PyErr_Occurred()) SWIG_fail;
32438 }
32439 resultobj = SWIG_Py_Void();
32440 return resultobj;
32441 fail:
32442 return NULL;
32443 }
32444
32445
32446 SWIGINTERN PyObject *_wrap_delete_DropSource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32447 PyObject *resultobj = 0;
32448 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32449 void *argp1 = 0 ;
32450 int res1 = 0 ;
32451 PyObject *swig_obj[1] ;
32452
32453 if (!args) SWIG_fail;
32454 swig_obj[0] = args;
32455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_DISOWN | 0 );
32456 if (!SWIG_IsOK(res1)) {
32457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropSource" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32458 }
32459 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32460 {
32461 PyThreadState* __tstate = wxPyBeginAllowThreads();
32462 delete arg1;
32463
32464 wxPyEndAllowThreads(__tstate);
32465 if (PyErr_Occurred()) SWIG_fail;
32466 }
32467 resultobj = SWIG_Py_Void();
32468 return resultobj;
32469 fail:
32470 return NULL;
32471 }
32472
32473
32474 SWIGINTERN PyObject *_wrap_DropSource_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32475 PyObject *resultobj = 0;
32476 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32477 wxDataObject *arg2 = 0 ;
32478 void *argp1 = 0 ;
32479 int res1 = 0 ;
32480 void *argp2 = 0 ;
32481 int res2 = 0 ;
32482 PyObject * obj0 = 0 ;
32483 PyObject * obj1 = 0 ;
32484 char * kwnames[] = {
32485 (char *) "self",(char *) "data", NULL
32486 };
32487
32488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
32489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32490 if (!SWIG_IsOK(res1)) {
32491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetData" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32492 }
32493 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
32495 if (!SWIG_IsOK(res2)) {
32496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32497 }
32498 if (!argp2) {
32499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
32500 }
32501 arg2 = reinterpret_cast< wxDataObject * >(argp2);
32502 {
32503 PyThreadState* __tstate = wxPyBeginAllowThreads();
32504 (arg1)->SetData(*arg2);
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 resultobj = SWIG_Py_Void();
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_DropSource_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32516 PyObject *resultobj = 0;
32517 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32518 wxDataObject *result = 0 ;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 PyObject *swig_obj[1] ;
32522
32523 if (!args) SWIG_fail;
32524 swig_obj[0] = args;
32525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32526 if (!SWIG_IsOK(res1)) {
32527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32528 }
32529 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 result = (wxDataObject *)(arg1)->GetDataObject();
32533 wxPyEndAllowThreads(__tstate);
32534 if (PyErr_Occurred()) SWIG_fail;
32535 }
32536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 SWIGINTERN PyObject *_wrap_DropSource_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32544 PyObject *resultobj = 0;
32545 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32546 wxDragResult arg2 ;
32547 wxCursor *arg3 = 0 ;
32548 void *argp1 = 0 ;
32549 int res1 = 0 ;
32550 int val2 ;
32551 int ecode2 = 0 ;
32552 void *argp3 = 0 ;
32553 int res3 = 0 ;
32554 PyObject * obj0 = 0 ;
32555 PyObject * obj1 = 0 ;
32556 PyObject * obj2 = 0 ;
32557 char * kwnames[] = {
32558 (char *) "self",(char *) "res",(char *) "cursor", NULL
32559 };
32560
32561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32563 if (!SWIG_IsOK(res1)) {
32564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_SetCursor" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32565 }
32566 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32567 ecode2 = SWIG_AsVal_int(obj1, &val2);
32568 if (!SWIG_IsOK(ecode2)) {
32569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_SetCursor" "', expected argument " "2"" of type '" "wxDragResult""'");
32570 }
32571 arg2 = static_cast< wxDragResult >(val2);
32572 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxCursor, 0 | 0);
32573 if (!SWIG_IsOK(res3)) {
32574 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32575 }
32576 if (!argp3) {
32577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropSource_SetCursor" "', expected argument " "3"" of type '" "wxCursor const &""'");
32578 }
32579 arg3 = reinterpret_cast< wxCursor * >(argp3);
32580 {
32581 PyThreadState* __tstate = wxPyBeginAllowThreads();
32582 (arg1)->SetCursor(arg2,(wxCursor const &)*arg3);
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 resultobj = SWIG_Py_Void();
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *_wrap_DropSource_DoDragDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32594 PyObject *resultobj = 0;
32595 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32596 int arg2 = (int) wxDrag_CopyOnly ;
32597 wxDragResult result;
32598 void *argp1 = 0 ;
32599 int res1 = 0 ;
32600 int val2 ;
32601 int ecode2 = 0 ;
32602 PyObject * obj0 = 0 ;
32603 PyObject * obj1 = 0 ;
32604 char * kwnames[] = {
32605 (char *) "self",(char *) "flags", NULL
32606 };
32607
32608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) SWIG_fail;
32609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32610 if (!SWIG_IsOK(res1)) {
32611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_DoDragDrop" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32612 }
32613 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32614 if (obj1) {
32615 ecode2 = SWIG_AsVal_int(obj1, &val2);
32616 if (!SWIG_IsOK(ecode2)) {
32617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_DoDragDrop" "', expected argument " "2"" of type '" "int""'");
32618 }
32619 arg2 = static_cast< int >(val2);
32620 }
32621 {
32622 PyThreadState* __tstate = wxPyBeginAllowThreads();
32623 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
32624 wxPyEndAllowThreads(__tstate);
32625 if (PyErr_Occurred()) SWIG_fail;
32626 }
32627 resultobj = SWIG_From_int(static_cast< int >(result));
32628 return resultobj;
32629 fail:
32630 return NULL;
32631 }
32632
32633
32634 SWIGINTERN PyObject *_wrap_DropSource_GiveFeedback(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32635 PyObject *resultobj = 0;
32636 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
32637 wxDragResult arg2 ;
32638 bool result;
32639 void *argp1 = 0 ;
32640 int res1 = 0 ;
32641 int val2 ;
32642 int ecode2 = 0 ;
32643 PyObject * obj0 = 0 ;
32644 PyObject * obj1 = 0 ;
32645 char * kwnames[] = {
32646 (char *) "self",(char *) "effect", NULL
32647 };
32648
32649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_GiveFeedback",kwnames,&obj0,&obj1)) SWIG_fail;
32650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropSource, 0 | 0 );
32651 if (!SWIG_IsOK(res1)) {
32652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropSource_GiveFeedback" "', expected argument " "1"" of type '" "wxPyDropSource *""'");
32653 }
32654 arg1 = reinterpret_cast< wxPyDropSource * >(argp1);
32655 ecode2 = SWIG_AsVal_int(obj1, &val2);
32656 if (!SWIG_IsOK(ecode2)) {
32657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropSource_GiveFeedback" "', expected argument " "2"" of type '" "wxDragResult""'");
32658 }
32659 arg2 = static_cast< wxDragResult >(val2);
32660 {
32661 PyThreadState* __tstate = wxPyBeginAllowThreads();
32662 result = (bool)(arg1)->GiveFeedback(arg2);
32663 wxPyEndAllowThreads(__tstate);
32664 if (PyErr_Occurred()) SWIG_fail;
32665 }
32666 {
32667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32668 }
32669 return resultobj;
32670 fail:
32671 return NULL;
32672 }
32673
32674
32675 SWIGINTERN PyObject *DropSource_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32676 PyObject *obj;
32677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32678 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropSource, SWIG_NewClientData(obj));
32679 return SWIG_Py_Void();
32680 }
32681
32682 SWIGINTERN PyObject *DropSource_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32683 return SWIG_Python_InitShadowInstance(args);
32684 }
32685
32686 SWIGINTERN PyObject *_wrap_new_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32687 PyObject *resultobj = 0;
32688 wxDataObject *arg1 = (wxDataObject *) NULL ;
32689 wxPyDropTarget *result = 0 ;
32690 int res1 = 0 ;
32691 PyObject * obj0 = 0 ;
32692 char * kwnames[] = {
32693 (char *) "dataObject", NULL
32694 };
32695
32696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) SWIG_fail;
32697 if (obj0) {
32698 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32699 if (!SWIG_IsOK(res1)) {
32700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DropTarget" "', expected argument " "1"" of type '" "wxDataObject *""'");
32701 }
32702 }
32703 {
32704 PyThreadState* __tstate = wxPyBeginAllowThreads();
32705 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
32706 wxPyEndAllowThreads(__tstate);
32707 if (PyErr_Occurred()) SWIG_fail;
32708 }
32709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_NEW | 0 );
32710 return resultobj;
32711 fail:
32712 return NULL;
32713 }
32714
32715
32716 SWIGINTERN PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32717 PyObject *resultobj = 0;
32718 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32719 PyObject *arg2 = (PyObject *) 0 ;
32720 PyObject *arg3 = (PyObject *) 0 ;
32721 void *argp1 = 0 ;
32722 int res1 = 0 ;
32723 PyObject * obj0 = 0 ;
32724 PyObject * obj1 = 0 ;
32725 PyObject * obj2 = 0 ;
32726 char * kwnames[] = {
32727 (char *) "self",(char *) "self",(char *) "_class", NULL
32728 };
32729
32730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32732 if (!SWIG_IsOK(res1)) {
32733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32734 }
32735 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32736 arg2 = obj1;
32737 arg3 = obj2;
32738 {
32739 PyThreadState* __tstate = wxPyBeginAllowThreads();
32740 (arg1)->_setCallbackInfo(arg2,arg3);
32741 wxPyEndAllowThreads(__tstate);
32742 if (PyErr_Occurred()) SWIG_fail;
32743 }
32744 resultobj = SWIG_Py_Void();
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_delete_DropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 PyObject *resultobj = 0;
32753 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32754 void *argp1 = 0 ;
32755 int res1 = 0 ;
32756 PyObject *swig_obj[1] ;
32757
32758 if (!args) SWIG_fail;
32759 swig_obj[0] = args;
32760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DropTarget" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32763 }
32764 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32765 {
32766 PyThreadState* __tstate = wxPyBeginAllowThreads();
32767 delete arg1;
32768
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 resultobj = SWIG_Py_Void();
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_DropTarget_GetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32782 wxDataObject *result = 0 ;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32792 }
32793 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 result = (wxDataObject *)(arg1)->GetDataObject();
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDataObject, 0 | 0 );
32801 return resultobj;
32802 fail:
32803 return NULL;
32804 }
32805
32806
32807 SWIGINTERN PyObject *_wrap_DropTarget_SetDataObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32808 PyObject *resultobj = 0;
32809 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32810 wxDataObject *arg2 = (wxDataObject *) 0 ;
32811 void *argp1 = 0 ;
32812 int res1 = 0 ;
32813 int res2 = 0 ;
32814 PyObject * obj0 = 0 ;
32815 PyObject * obj1 = 0 ;
32816 char * kwnames[] = {
32817 (char *) "self",(char *) "dataObject", NULL
32818 };
32819
32820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) SWIG_fail;
32821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32822 if (!SWIG_IsOK(res1)) {
32823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDataObject" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32824 }
32825 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32826 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
32827 if (!SWIG_IsOK(res2)) {
32828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTarget_SetDataObject" "', expected argument " "2"" of type '" "wxDataObject *""'");
32829 }
32830 {
32831 PyThreadState* __tstate = wxPyBeginAllowThreads();
32832 (arg1)->SetDataObject(arg2);
32833 wxPyEndAllowThreads(__tstate);
32834 if (PyErr_Occurred()) SWIG_fail;
32835 }
32836 resultobj = SWIG_Py_Void();
32837 return resultobj;
32838 fail:
32839 return NULL;
32840 }
32841
32842
32843 SWIGINTERN PyObject *_wrap_DropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32844 PyObject *resultobj = 0;
32845 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32846 int arg2 ;
32847 int arg3 ;
32848 wxDragResult arg4 ;
32849 wxDragResult result;
32850 void *argp1 = 0 ;
32851 int res1 = 0 ;
32852 int val2 ;
32853 int ecode2 = 0 ;
32854 int val3 ;
32855 int ecode3 = 0 ;
32856 int val4 ;
32857 int ecode4 = 0 ;
32858 PyObject * obj0 = 0 ;
32859 PyObject * obj1 = 0 ;
32860 PyObject * obj2 = 0 ;
32861 PyObject * obj3 = 0 ;
32862 char * kwnames[] = {
32863 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32864 };
32865
32866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32868 if (!SWIG_IsOK(res1)) {
32869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32870 }
32871 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32872 ecode2 = SWIG_AsVal_int(obj1, &val2);
32873 if (!SWIG_IsOK(ecode2)) {
32874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
32875 }
32876 arg2 = static_cast< int >(val2);
32877 ecode3 = SWIG_AsVal_int(obj2, &val3);
32878 if (!SWIG_IsOK(ecode3)) {
32879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
32880 }
32881 arg3 = static_cast< int >(val3);
32882 ecode4 = SWIG_AsVal_int(obj3, &val4);
32883 if (!SWIG_IsOK(ecode4)) {
32884 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
32885 }
32886 arg4 = static_cast< wxDragResult >(val4);
32887 {
32888 PyThreadState* __tstate = wxPyBeginAllowThreads();
32889 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
32890 wxPyEndAllowThreads(__tstate);
32891 if (PyErr_Occurred()) SWIG_fail;
32892 }
32893 resultobj = SWIG_From_int(static_cast< int >(result));
32894 return resultobj;
32895 fail:
32896 return NULL;
32897 }
32898
32899
32900 SWIGINTERN PyObject *_wrap_DropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32901 PyObject *resultobj = 0;
32902 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32903 int arg2 ;
32904 int arg3 ;
32905 wxDragResult arg4 ;
32906 wxDragResult result;
32907 void *argp1 = 0 ;
32908 int res1 = 0 ;
32909 int val2 ;
32910 int ecode2 = 0 ;
32911 int val3 ;
32912 int ecode3 = 0 ;
32913 int val4 ;
32914 int ecode4 = 0 ;
32915 PyObject * obj0 = 0 ;
32916 PyObject * obj1 = 0 ;
32917 PyObject * obj2 = 0 ;
32918 PyObject * obj3 = 0 ;
32919 char * kwnames[] = {
32920 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
32921 };
32922
32923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32925 if (!SWIG_IsOK(res1)) {
32926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32927 }
32928 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32929 ecode2 = SWIG_AsVal_int(obj1, &val2);
32930 if (!SWIG_IsOK(ecode2)) {
32931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
32932 }
32933 arg2 = static_cast< int >(val2);
32934 ecode3 = SWIG_AsVal_int(obj2, &val3);
32935 if (!SWIG_IsOK(ecode3)) {
32936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
32937 }
32938 arg3 = static_cast< int >(val3);
32939 ecode4 = SWIG_AsVal_int(obj3, &val4);
32940 if (!SWIG_IsOK(ecode4)) {
32941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
32942 }
32943 arg4 = static_cast< wxDragResult >(val4);
32944 {
32945 PyThreadState* __tstate = wxPyBeginAllowThreads();
32946 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
32947 wxPyEndAllowThreads(__tstate);
32948 if (PyErr_Occurred()) SWIG_fail;
32949 }
32950 resultobj = SWIG_From_int(static_cast< int >(result));
32951 return resultobj;
32952 fail:
32953 return NULL;
32954 }
32955
32956
32957 SWIGINTERN PyObject *_wrap_DropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32958 PyObject *resultobj = 0;
32959 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32960 void *argp1 = 0 ;
32961 int res1 = 0 ;
32962 PyObject *swig_obj[1] ;
32963
32964 if (!args) SWIG_fail;
32965 swig_obj[0] = args;
32966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
32967 if (!SWIG_IsOK(res1)) {
32968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
32969 }
32970 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 (arg1)->OnLeave();
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 resultobj = SWIG_Py_Void();
32978 return resultobj;
32979 fail:
32980 return NULL;
32981 }
32982
32983
32984 SWIGINTERN PyObject *_wrap_DropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32985 PyObject *resultobj = 0;
32986 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
32987 int arg2 ;
32988 int arg3 ;
32989 bool result;
32990 void *argp1 = 0 ;
32991 int res1 = 0 ;
32992 int val2 ;
32993 int ecode2 = 0 ;
32994 int val3 ;
32995 int ecode3 = 0 ;
32996 PyObject * obj0 = 0 ;
32997 PyObject * obj1 = 0 ;
32998 PyObject * obj2 = 0 ;
32999 char * kwnames[] = {
33000 (char *) "self",(char *) "x",(char *) "y", NULL
33001 };
33002
33003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33005 if (!SWIG_IsOK(res1)) {
33006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33007 }
33008 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33009 ecode2 = SWIG_AsVal_int(obj1, &val2);
33010 if (!SWIG_IsOK(ecode2)) {
33011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33012 }
33013 arg2 = static_cast< int >(val2);
33014 ecode3 = SWIG_AsVal_int(obj2, &val3);
33015 if (!SWIG_IsOK(ecode3)) {
33016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33017 }
33018 arg3 = static_cast< int >(val3);
33019 {
33020 PyThreadState* __tstate = wxPyBeginAllowThreads();
33021 result = (bool)(arg1)->OnDrop(arg2,arg3);
33022 wxPyEndAllowThreads(__tstate);
33023 if (PyErr_Occurred()) SWIG_fail;
33024 }
33025 {
33026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33027 }
33028 return resultobj;
33029 fail:
33030 return NULL;
33031 }
33032
33033
33034 SWIGINTERN PyObject *_wrap_DropTarget_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33035 PyObject *resultobj = 0;
33036 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33037 bool result;
33038 void *argp1 = 0 ;
33039 int res1 = 0 ;
33040 PyObject *swig_obj[1] ;
33041
33042 if (!args) SWIG_fail;
33043 swig_obj[0] = args;
33044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33045 if (!SWIG_IsOK(res1)) {
33046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetData" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33047 }
33048 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33049 {
33050 PyThreadState* __tstate = wxPyBeginAllowThreads();
33051 result = (bool)(arg1)->GetData();
33052 wxPyEndAllowThreads(__tstate);
33053 if (PyErr_Occurred()) SWIG_fail;
33054 }
33055 {
33056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33057 }
33058 return resultobj;
33059 fail:
33060 return NULL;
33061 }
33062
33063
33064 SWIGINTERN PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33065 PyObject *resultobj = 0;
33066 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33067 wxDragResult arg2 ;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 int val2 ;
33071 int ecode2 = 0 ;
33072 PyObject * obj0 = 0 ;
33073 PyObject * obj1 = 0 ;
33074 char * kwnames[] = {
33075 (char *) "self",(char *) "action", NULL
33076 };
33077
33078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) SWIG_fail;
33079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33080 if (!SWIG_IsOK(res1)) {
33081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33082 }
33083 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33084 ecode2 = SWIG_AsVal_int(obj1, &val2);
33085 if (!SWIG_IsOK(ecode2)) {
33086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropTarget_SetDefaultAction" "', expected argument " "2"" of type '" "wxDragResult""'");
33087 }
33088 arg2 = static_cast< wxDragResult >(val2);
33089 {
33090 PyThreadState* __tstate = wxPyBeginAllowThreads();
33091 (arg1)->SetDefaultAction(arg2);
33092 wxPyEndAllowThreads(__tstate);
33093 if (PyErr_Occurred()) SWIG_fail;
33094 }
33095 resultobj = SWIG_Py_Void();
33096 return resultobj;
33097 fail:
33098 return NULL;
33099 }
33100
33101
33102 SWIGINTERN PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33103 PyObject *resultobj = 0;
33104 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
33105 wxDragResult result;
33106 void *argp1 = 0 ;
33107 int res1 = 0 ;
33108 PyObject *swig_obj[1] ;
33109
33110 if (!args) SWIG_fail;
33111 swig_obj[0] = args;
33112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
33113 if (!SWIG_IsOK(res1)) {
33114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTarget_GetDefaultAction" "', expected argument " "1"" of type '" "wxPyDropTarget *""'");
33115 }
33116 arg1 = reinterpret_cast< wxPyDropTarget * >(argp1);
33117 {
33118 PyThreadState* __tstate = wxPyBeginAllowThreads();
33119 result = (wxDragResult)(arg1)->GetDefaultAction();
33120 wxPyEndAllowThreads(__tstate);
33121 if (PyErr_Occurred()) SWIG_fail;
33122 }
33123 resultobj = SWIG_From_int(static_cast< int >(result));
33124 return resultobj;
33125 fail:
33126 return NULL;
33127 }
33128
33129
33130 SWIGINTERN PyObject *DropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33131 PyObject *obj;
33132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33133 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyDropTarget, SWIG_NewClientData(obj));
33134 return SWIG_Py_Void();
33135 }
33136
33137 SWIGINTERN PyObject *DropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33138 return SWIG_Python_InitShadowInstance(args);
33139 }
33140
33141 SWIGINTERN PyObject *_wrap_new_TextDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33142 PyObject *resultobj = 0;
33143 wxPyTextDropTarget *result = 0 ;
33144
33145 if (!SWIG_Python_UnpackTuple(args,"new_TextDropTarget",0,0,0)) SWIG_fail;
33146 {
33147 PyThreadState* __tstate = wxPyBeginAllowThreads();
33148 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
33149 wxPyEndAllowThreads(__tstate);
33150 if (PyErr_Occurred()) SWIG_fail;
33151 }
33152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_NEW | 0 );
33153 return resultobj;
33154 fail:
33155 return NULL;
33156 }
33157
33158
33159 SWIGINTERN PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33160 PyObject *resultobj = 0;
33161 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33162 PyObject *arg2 = (PyObject *) 0 ;
33163 PyObject *arg3 = (PyObject *) 0 ;
33164 void *argp1 = 0 ;
33165 int res1 = 0 ;
33166 PyObject * obj0 = 0 ;
33167 PyObject * obj1 = 0 ;
33168 PyObject * obj2 = 0 ;
33169 char * kwnames[] = {
33170 (char *) "self",(char *) "self",(char *) "_class", NULL
33171 };
33172
33173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33175 if (!SWIG_IsOK(res1)) {
33176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33177 }
33178 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33179 arg2 = obj1;
33180 arg3 = obj2;
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 (arg1)->_setCallbackInfo(arg2,arg3);
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 resultobj = SWIG_Py_Void();
33188 return resultobj;
33189 fail:
33190 return NULL;
33191 }
33192
33193
33194 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDropText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33195 PyObject *resultobj = 0;
33196 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33197 int arg2 ;
33198 int arg3 ;
33199 wxString *arg4 = 0 ;
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 bool temp4 = false ;
33208 PyObject * obj0 = 0 ;
33209 PyObject * obj1 = 0 ;
33210 PyObject * obj2 = 0 ;
33211 PyObject * obj3 = 0 ;
33212 char * kwnames[] = {
33213 (char *) "self",(char *) "x",(char *) "y",(char *) "text", NULL
33214 };
33215
33216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDropText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33218 if (!SWIG_IsOK(res1)) {
33219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDropText" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33220 }
33221 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33222 ecode2 = SWIG_AsVal_int(obj1, &val2);
33223 if (!SWIG_IsOK(ecode2)) {
33224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDropText" "', expected argument " "2"" of type '" "int""'");
33225 }
33226 arg2 = static_cast< int >(val2);
33227 ecode3 = SWIG_AsVal_int(obj2, &val3);
33228 if (!SWIG_IsOK(ecode3)) {
33229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDropText" "', expected argument " "3"" of type '" "int""'");
33230 }
33231 arg3 = static_cast< int >(val3);
33232 {
33233 arg4 = wxString_in_helper(obj3);
33234 if (arg4 == NULL) SWIG_fail;
33235 temp4 = true;
33236 }
33237 {
33238 PyThreadState* __tstate = wxPyBeginAllowThreads();
33239 result = (bool)(arg1)->OnDropText(arg2,arg3,(wxString const &)*arg4);
33240 wxPyEndAllowThreads(__tstate);
33241 if (PyErr_Occurred()) SWIG_fail;
33242 }
33243 {
33244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33245 }
33246 {
33247 if (temp4)
33248 delete arg4;
33249 }
33250 return resultobj;
33251 fail:
33252 {
33253 if (temp4)
33254 delete arg4;
33255 }
33256 return NULL;
33257 }
33258
33259
33260 SWIGINTERN PyObject *_wrap_TextDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33261 PyObject *resultobj = 0;
33262 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33263 int arg2 ;
33264 int arg3 ;
33265 wxDragResult arg4 ;
33266 wxDragResult result;
33267 void *argp1 = 0 ;
33268 int res1 = 0 ;
33269 int val2 ;
33270 int ecode2 = 0 ;
33271 int val3 ;
33272 int ecode3 = 0 ;
33273 int val4 ;
33274 int ecode4 = 0 ;
33275 PyObject * obj0 = 0 ;
33276 PyObject * obj1 = 0 ;
33277 PyObject * obj2 = 0 ;
33278 PyObject * obj3 = 0 ;
33279 char * kwnames[] = {
33280 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33281 };
33282
33283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33285 if (!SWIG_IsOK(res1)) {
33286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33287 }
33288 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33289 ecode2 = SWIG_AsVal_int(obj1, &val2);
33290 if (!SWIG_IsOK(ecode2)) {
33291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33292 }
33293 arg2 = static_cast< int >(val2);
33294 ecode3 = SWIG_AsVal_int(obj2, &val3);
33295 if (!SWIG_IsOK(ecode3)) {
33296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33297 }
33298 arg3 = static_cast< int >(val3);
33299 ecode4 = SWIG_AsVal_int(obj3, &val4);
33300 if (!SWIG_IsOK(ecode4)) {
33301 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33302 }
33303 arg4 = static_cast< wxDragResult >(val4);
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 resultobj = SWIG_From_int(static_cast< int >(result));
33311 return resultobj;
33312 fail:
33313 return NULL;
33314 }
33315
33316
33317 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33318 PyObject *resultobj = 0;
33319 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33320 int arg2 ;
33321 int arg3 ;
33322 wxDragResult arg4 ;
33323 wxDragResult result;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 int val2 ;
33327 int ecode2 = 0 ;
33328 int val3 ;
33329 int ecode3 = 0 ;
33330 int val4 ;
33331 int ecode4 = 0 ;
33332 PyObject * obj0 = 0 ;
33333 PyObject * obj1 = 0 ;
33334 PyObject * obj2 = 0 ;
33335 PyObject * obj3 = 0 ;
33336 char * kwnames[] = {
33337 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33338 };
33339
33340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33342 if (!SWIG_IsOK(res1)) {
33343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33344 }
33345 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33346 ecode2 = SWIG_AsVal_int(obj1, &val2);
33347 if (!SWIG_IsOK(ecode2)) {
33348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33349 }
33350 arg2 = static_cast< int >(val2);
33351 ecode3 = SWIG_AsVal_int(obj2, &val3);
33352 if (!SWIG_IsOK(ecode3)) {
33353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33354 }
33355 arg3 = static_cast< int >(val3);
33356 ecode4 = SWIG_AsVal_int(obj3, &val4);
33357 if (!SWIG_IsOK(ecode4)) {
33358 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33359 }
33360 arg4 = static_cast< wxDragResult >(val4);
33361 {
33362 PyThreadState* __tstate = wxPyBeginAllowThreads();
33363 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33364 wxPyEndAllowThreads(__tstate);
33365 if (PyErr_Occurred()) SWIG_fail;
33366 }
33367 resultobj = SWIG_From_int(static_cast< int >(result));
33368 return resultobj;
33369 fail:
33370 return NULL;
33371 }
33372
33373
33374 SWIGINTERN PyObject *_wrap_TextDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33375 PyObject *resultobj = 0;
33376 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33377 void *argp1 = 0 ;
33378 int res1 = 0 ;
33379 PyObject *swig_obj[1] ;
33380
33381 if (!args) SWIG_fail;
33382 swig_obj[0] = args;
33383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33384 if (!SWIG_IsOK(res1)) {
33385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33386 }
33387 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 (arg1)->OnLeave();
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 resultobj = SWIG_Py_Void();
33395 return resultobj;
33396 fail:
33397 return NULL;
33398 }
33399
33400
33401 SWIGINTERN PyObject *_wrap_TextDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33402 PyObject *resultobj = 0;
33403 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33404 int arg2 ;
33405 int arg3 ;
33406 bool result;
33407 void *argp1 = 0 ;
33408 int res1 = 0 ;
33409 int val2 ;
33410 int ecode2 = 0 ;
33411 int val3 ;
33412 int ecode3 = 0 ;
33413 PyObject * obj0 = 0 ;
33414 PyObject * obj1 = 0 ;
33415 PyObject * obj2 = 0 ;
33416 char * kwnames[] = {
33417 (char *) "self",(char *) "x",(char *) "y", NULL
33418 };
33419
33420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33422 if (!SWIG_IsOK(res1)) {
33423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33424 }
33425 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33426 ecode2 = SWIG_AsVal_int(obj1, &val2);
33427 if (!SWIG_IsOK(ecode2)) {
33428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33429 }
33430 arg2 = static_cast< int >(val2);
33431 ecode3 = SWIG_AsVal_int(obj2, &val3);
33432 if (!SWIG_IsOK(ecode3)) {
33433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33434 }
33435 arg3 = static_cast< int >(val3);
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 result = (bool)(arg1)->OnDrop(arg2,arg3);
33439 wxPyEndAllowThreads(__tstate);
33440 if (PyErr_Occurred()) SWIG_fail;
33441 }
33442 {
33443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33444 }
33445 return resultobj;
33446 fail:
33447 return NULL;
33448 }
33449
33450
33451 SWIGINTERN PyObject *_wrap_TextDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33452 PyObject *resultobj = 0;
33453 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
33454 int arg2 ;
33455 int arg3 ;
33456 wxDragResult arg4 ;
33457 wxDragResult result;
33458 void *argp1 = 0 ;
33459 int res1 = 0 ;
33460 int val2 ;
33461 int ecode2 = 0 ;
33462 int val3 ;
33463 int ecode3 = 0 ;
33464 int val4 ;
33465 int ecode4 = 0 ;
33466 PyObject * obj0 = 0 ;
33467 PyObject * obj1 = 0 ;
33468 PyObject * obj2 = 0 ;
33469 PyObject * obj3 = 0 ;
33470 char * kwnames[] = {
33471 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33472 };
33473
33474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyTextDropTarget, 0 | 0 );
33476 if (!SWIG_IsOK(res1)) {
33477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyTextDropTarget *""'");
33478 }
33479 arg1 = reinterpret_cast< wxPyTextDropTarget * >(argp1);
33480 ecode2 = SWIG_AsVal_int(obj1, &val2);
33481 if (!SWIG_IsOK(ecode2)) {
33482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33483 }
33484 arg2 = static_cast< int >(val2);
33485 ecode3 = SWIG_AsVal_int(obj2, &val3);
33486 if (!SWIG_IsOK(ecode3)) {
33487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TextDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33488 }
33489 arg3 = static_cast< int >(val3);
33490 ecode4 = SWIG_AsVal_int(obj3, &val4);
33491 if (!SWIG_IsOK(ecode4)) {
33492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TextDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33493 }
33494 arg4 = static_cast< wxDragResult >(val4);
33495 {
33496 PyThreadState* __tstate = wxPyBeginAllowThreads();
33497 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33498 wxPyEndAllowThreads(__tstate);
33499 if (PyErr_Occurred()) SWIG_fail;
33500 }
33501 resultobj = SWIG_From_int(static_cast< int >(result));
33502 return resultobj;
33503 fail:
33504 return NULL;
33505 }
33506
33507
33508 SWIGINTERN PyObject *TextDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33509 PyObject *obj;
33510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33511 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyTextDropTarget, SWIG_NewClientData(obj));
33512 return SWIG_Py_Void();
33513 }
33514
33515 SWIGINTERN PyObject *TextDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33516 return SWIG_Python_InitShadowInstance(args);
33517 }
33518
33519 SWIGINTERN PyObject *_wrap_new_FileDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33520 PyObject *resultobj = 0;
33521 wxPyFileDropTarget *result = 0 ;
33522
33523 if (!SWIG_Python_UnpackTuple(args,"new_FileDropTarget",0,0,0)) SWIG_fail;
33524 {
33525 PyThreadState* __tstate = wxPyBeginAllowThreads();
33526 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
33527 wxPyEndAllowThreads(__tstate);
33528 if (PyErr_Occurred()) SWIG_fail;
33529 }
33530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_NEW | 0 );
33531 return resultobj;
33532 fail:
33533 return NULL;
33534 }
33535
33536
33537 SWIGINTERN PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33538 PyObject *resultobj = 0;
33539 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33540 PyObject *arg2 = (PyObject *) 0 ;
33541 PyObject *arg3 = (PyObject *) 0 ;
33542 void *argp1 = 0 ;
33543 int res1 = 0 ;
33544 PyObject * obj0 = 0 ;
33545 PyObject * obj1 = 0 ;
33546 PyObject * obj2 = 0 ;
33547 char * kwnames[] = {
33548 (char *) "self",(char *) "self",(char *) "_class", NULL
33549 };
33550
33551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33553 if (!SWIG_IsOK(res1)) {
33554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33555 }
33556 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33557 arg2 = obj1;
33558 arg3 = obj2;
33559 {
33560 PyThreadState* __tstate = wxPyBeginAllowThreads();
33561 (arg1)->_setCallbackInfo(arg2,arg3);
33562 wxPyEndAllowThreads(__tstate);
33563 if (PyErr_Occurred()) SWIG_fail;
33564 }
33565 resultobj = SWIG_Py_Void();
33566 return resultobj;
33567 fail:
33568 return NULL;
33569 }
33570
33571
33572 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDropFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33573 PyObject *resultobj = 0;
33574 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33575 int arg2 ;
33576 int arg3 ;
33577 wxArrayString *arg4 = 0 ;
33578 bool result;
33579 void *argp1 = 0 ;
33580 int res1 = 0 ;
33581 int val2 ;
33582 int ecode2 = 0 ;
33583 int val3 ;
33584 int ecode3 = 0 ;
33585 bool temp4 = false ;
33586 PyObject * obj0 = 0 ;
33587 PyObject * obj1 = 0 ;
33588 PyObject * obj2 = 0 ;
33589 PyObject * obj3 = 0 ;
33590 char * kwnames[] = {
33591 (char *) "self",(char *) "x",(char *) "y",(char *) "filenames", NULL
33592 };
33593
33594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDropFiles",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33596 if (!SWIG_IsOK(res1)) {
33597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33598 }
33599 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33600 ecode2 = SWIG_AsVal_int(obj1, &val2);
33601 if (!SWIG_IsOK(ecode2)) {
33602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "2"" of type '" "int""'");
33603 }
33604 arg2 = static_cast< int >(val2);
33605 ecode3 = SWIG_AsVal_int(obj2, &val3);
33606 if (!SWIG_IsOK(ecode3)) {
33607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDropFiles" "', expected argument " "3"" of type '" "int""'");
33608 }
33609 arg3 = static_cast< int >(val3);
33610 {
33611 if (! PySequence_Check(obj3)) {
33612 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
33613 SWIG_fail;
33614 }
33615 arg4 = new wxArrayString;
33616 temp4 = true;
33617 int i, len=PySequence_Length(obj3);
33618 for (i=0; i<len; i++) {
33619 PyObject* item = PySequence_GetItem(obj3, i);
33620 wxString* s = wxString_in_helper(item);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 arg4->Add(*s);
33623 delete s;
33624 Py_DECREF(item);
33625 }
33626 }
33627 {
33628 PyThreadState* __tstate = wxPyBeginAllowThreads();
33629 result = (bool)(arg1)->OnDropFiles(arg2,arg3,(wxArrayString const &)*arg4);
33630 wxPyEndAllowThreads(__tstate);
33631 if (PyErr_Occurred()) SWIG_fail;
33632 }
33633 {
33634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33635 }
33636 {
33637 if (temp4) delete arg4;
33638 }
33639 return resultobj;
33640 fail:
33641 {
33642 if (temp4) delete arg4;
33643 }
33644 return NULL;
33645 }
33646
33647
33648 SWIGINTERN PyObject *_wrap_FileDropTarget_OnEnter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33649 PyObject *resultobj = 0;
33650 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33651 int arg2 ;
33652 int arg3 ;
33653 wxDragResult arg4 ;
33654 wxDragResult result;
33655 void *argp1 = 0 ;
33656 int res1 = 0 ;
33657 int val2 ;
33658 int ecode2 = 0 ;
33659 int val3 ;
33660 int ecode3 = 0 ;
33661 int val4 ;
33662 int ecode4 = 0 ;
33663 PyObject * obj0 = 0 ;
33664 PyObject * obj1 = 0 ;
33665 PyObject * obj2 = 0 ;
33666 PyObject * obj3 = 0 ;
33667 char * kwnames[] = {
33668 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33669 };
33670
33671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33673 if (!SWIG_IsOK(res1)) {
33674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnEnter" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33675 }
33676 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33677 ecode2 = SWIG_AsVal_int(obj1, &val2);
33678 if (!SWIG_IsOK(ecode2)) {
33679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnEnter" "', expected argument " "2"" of type '" "int""'");
33680 }
33681 arg2 = static_cast< int >(val2);
33682 ecode3 = SWIG_AsVal_int(obj2, &val3);
33683 if (!SWIG_IsOK(ecode3)) {
33684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnEnter" "', expected argument " "3"" of type '" "int""'");
33685 }
33686 arg3 = static_cast< int >(val3);
33687 ecode4 = SWIG_AsVal_int(obj3, &val4);
33688 if (!SWIG_IsOK(ecode4)) {
33689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnEnter" "', expected argument " "4"" of type '" "wxDragResult""'");
33690 }
33691 arg4 = static_cast< wxDragResult >(val4);
33692 {
33693 PyThreadState* __tstate = wxPyBeginAllowThreads();
33694 result = (wxDragResult)(arg1)->OnEnter(arg2,arg3,arg4);
33695 wxPyEndAllowThreads(__tstate);
33696 if (PyErr_Occurred()) SWIG_fail;
33697 }
33698 resultobj = SWIG_From_int(static_cast< int >(result));
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDragOver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33706 PyObject *resultobj = 0;
33707 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33708 int arg2 ;
33709 int arg3 ;
33710 wxDragResult arg4 ;
33711 wxDragResult result;
33712 void *argp1 = 0 ;
33713 int res1 = 0 ;
33714 int val2 ;
33715 int ecode2 = 0 ;
33716 int val3 ;
33717 int ecode3 = 0 ;
33718 int val4 ;
33719 int ecode4 = 0 ;
33720 PyObject * obj0 = 0 ;
33721 PyObject * obj1 = 0 ;
33722 PyObject * obj2 = 0 ;
33723 PyObject * obj3 = 0 ;
33724 char * kwnames[] = {
33725 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33726 };
33727
33728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33730 if (!SWIG_IsOK(res1)) {
33731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33732 }
33733 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33734 ecode2 = SWIG_AsVal_int(obj1, &val2);
33735 if (!SWIG_IsOK(ecode2)) {
33736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "2"" of type '" "int""'");
33737 }
33738 arg2 = static_cast< int >(val2);
33739 ecode3 = SWIG_AsVal_int(obj2, &val3);
33740 if (!SWIG_IsOK(ecode3)) {
33741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "3"" of type '" "int""'");
33742 }
33743 arg3 = static_cast< int >(val3);
33744 ecode4 = SWIG_AsVal_int(obj3, &val4);
33745 if (!SWIG_IsOK(ecode4)) {
33746 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnDragOver" "', expected argument " "4"" of type '" "wxDragResult""'");
33747 }
33748 arg4 = static_cast< wxDragResult >(val4);
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 result = (wxDragResult)(arg1)->OnDragOver(arg2,arg3,arg4);
33752 wxPyEndAllowThreads(__tstate);
33753 if (PyErr_Occurred()) SWIG_fail;
33754 }
33755 resultobj = SWIG_From_int(static_cast< int >(result));
33756 return resultobj;
33757 fail:
33758 return NULL;
33759 }
33760
33761
33762 SWIGINTERN PyObject *_wrap_FileDropTarget_OnLeave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33763 PyObject *resultobj = 0;
33764 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33765 void *argp1 = 0 ;
33766 int res1 = 0 ;
33767 PyObject *swig_obj[1] ;
33768
33769 if (!args) SWIG_fail;
33770 swig_obj[0] = args;
33771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33772 if (!SWIG_IsOK(res1)) {
33773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnLeave" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33774 }
33775 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 (arg1)->OnLeave();
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 resultobj = SWIG_Py_Void();
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 SWIGINTERN PyObject *_wrap_FileDropTarget_OnDrop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33790 PyObject *resultobj = 0;
33791 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33792 int arg2 ;
33793 int arg3 ;
33794 bool result;
33795 void *argp1 = 0 ;
33796 int res1 = 0 ;
33797 int val2 ;
33798 int ecode2 = 0 ;
33799 int val3 ;
33800 int ecode3 = 0 ;
33801 PyObject * obj0 = 0 ;
33802 PyObject * obj1 = 0 ;
33803 PyObject * obj2 = 0 ;
33804 char * kwnames[] = {
33805 (char *) "self",(char *) "x",(char *) "y", NULL
33806 };
33807
33808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_OnDrop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33810 if (!SWIG_IsOK(res1)) {
33811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnDrop" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33812 }
33813 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33814 ecode2 = SWIG_AsVal_int(obj1, &val2);
33815 if (!SWIG_IsOK(ecode2)) {
33816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnDrop" "', expected argument " "2"" of type '" "int""'");
33817 }
33818 arg2 = static_cast< int >(val2);
33819 ecode3 = SWIG_AsVal_int(obj2, &val3);
33820 if (!SWIG_IsOK(ecode3)) {
33821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnDrop" "', expected argument " "3"" of type '" "int""'");
33822 }
33823 arg3 = static_cast< int >(val3);
33824 {
33825 PyThreadState* __tstate = wxPyBeginAllowThreads();
33826 result = (bool)(arg1)->OnDrop(arg2,arg3);
33827 wxPyEndAllowThreads(__tstate);
33828 if (PyErr_Occurred()) SWIG_fail;
33829 }
33830 {
33831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33832 }
33833 return resultobj;
33834 fail:
33835 return NULL;
33836 }
33837
33838
33839 SWIGINTERN PyObject *_wrap_FileDropTarget_OnData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33840 PyObject *resultobj = 0;
33841 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
33842 int arg2 ;
33843 int arg3 ;
33844 wxDragResult arg4 ;
33845 wxDragResult result;
33846 void *argp1 = 0 ;
33847 int res1 = 0 ;
33848 int val2 ;
33849 int ecode2 = 0 ;
33850 int val3 ;
33851 int ecode3 = 0 ;
33852 int val4 ;
33853 int ecode4 = 0 ;
33854 PyObject * obj0 = 0 ;
33855 PyObject * obj1 = 0 ;
33856 PyObject * obj2 = 0 ;
33857 PyObject * obj3 = 0 ;
33858 char * kwnames[] = {
33859 (char *) "self",(char *) "x",(char *) "y",(char *) "_def", NULL
33860 };
33861
33862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileDropTarget, 0 | 0 );
33864 if (!SWIG_IsOK(res1)) {
33865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileDropTarget_OnData" "', expected argument " "1"" of type '" "wxPyFileDropTarget *""'");
33866 }
33867 arg1 = reinterpret_cast< wxPyFileDropTarget * >(argp1);
33868 ecode2 = SWIG_AsVal_int(obj1, &val2);
33869 if (!SWIG_IsOK(ecode2)) {
33870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FileDropTarget_OnData" "', expected argument " "2"" of type '" "int""'");
33871 }
33872 arg2 = static_cast< int >(val2);
33873 ecode3 = SWIG_AsVal_int(obj2, &val3);
33874 if (!SWIG_IsOK(ecode3)) {
33875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileDropTarget_OnData" "', expected argument " "3"" of type '" "int""'");
33876 }
33877 arg3 = static_cast< int >(val3);
33878 ecode4 = SWIG_AsVal_int(obj3, &val4);
33879 if (!SWIG_IsOK(ecode4)) {
33880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FileDropTarget_OnData" "', expected argument " "4"" of type '" "wxDragResult""'");
33881 }
33882 arg4 = static_cast< wxDragResult >(val4);
33883 {
33884 PyThreadState* __tstate = wxPyBeginAllowThreads();
33885 result = (wxDragResult)(arg1)->OnData(arg2,arg3,arg4);
33886 wxPyEndAllowThreads(__tstate);
33887 if (PyErr_Occurred()) SWIG_fail;
33888 }
33889 resultobj = SWIG_From_int(static_cast< int >(result));
33890 return resultobj;
33891 fail:
33892 return NULL;
33893 }
33894
33895
33896 SWIGINTERN PyObject *FileDropTarget_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33897 PyObject *obj;
33898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33899 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileDropTarget, SWIG_NewClientData(obj));
33900 return SWIG_Py_Void();
33901 }
33902
33903 SWIGINTERN PyObject *FileDropTarget_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33904 return SWIG_Python_InitShadowInstance(args);
33905 }
33906
33907 SWIGINTERN PyObject *_wrap_new_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33908 PyObject *resultobj = 0;
33909 wxClipboard *result = 0 ;
33910
33911 if (!SWIG_Python_UnpackTuple(args,"new_Clipboard",0,0,0)) SWIG_fail;
33912 {
33913 PyThreadState* __tstate = wxPyBeginAllowThreads();
33914 result = (wxClipboard *)new wxClipboard();
33915 wxPyEndAllowThreads(__tstate);
33916 if (PyErr_Occurred()) SWIG_fail;
33917 }
33918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, SWIG_POINTER_NEW | 0 );
33919 return resultobj;
33920 fail:
33921 return NULL;
33922 }
33923
33924
33925 SWIGINTERN PyObject *_wrap_delete_Clipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33926 PyObject *resultobj = 0;
33927 wxClipboard *arg1 = (wxClipboard *) 0 ;
33928 void *argp1 = 0 ;
33929 int res1 = 0 ;
33930 PyObject *swig_obj[1] ;
33931
33932 if (!args) SWIG_fail;
33933 swig_obj[0] = args;
33934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, SWIG_POINTER_DISOWN | 0 );
33935 if (!SWIG_IsOK(res1)) {
33936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Clipboard" "', expected argument " "1"" of type '" "wxClipboard *""'");
33937 }
33938 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33939 {
33940 PyThreadState* __tstate = wxPyBeginAllowThreads();
33941 delete arg1;
33942
33943 wxPyEndAllowThreads(__tstate);
33944 if (PyErr_Occurred()) SWIG_fail;
33945 }
33946 resultobj = SWIG_Py_Void();
33947 return resultobj;
33948 fail:
33949 return NULL;
33950 }
33951
33952
33953 SWIGINTERN PyObject *_wrap_Clipboard_Open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33954 PyObject *resultobj = 0;
33955 wxClipboard *arg1 = (wxClipboard *) 0 ;
33956 bool result;
33957 void *argp1 = 0 ;
33958 int res1 = 0 ;
33959 PyObject *swig_obj[1] ;
33960
33961 if (!args) SWIG_fail;
33962 swig_obj[0] = args;
33963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Open" "', expected argument " "1"" of type '" "wxClipboard *""'");
33966 }
33967 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33968 {
33969 PyThreadState* __tstate = wxPyBeginAllowThreads();
33970 result = (bool)(arg1)->Open();
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 {
33975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33976 }
33977 return resultobj;
33978 fail:
33979 return NULL;
33980 }
33981
33982
33983 SWIGINTERN PyObject *_wrap_Clipboard_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33984 PyObject *resultobj = 0;
33985 wxClipboard *arg1 = (wxClipboard *) 0 ;
33986 void *argp1 = 0 ;
33987 int res1 = 0 ;
33988 PyObject *swig_obj[1] ;
33989
33990 if (!args) SWIG_fail;
33991 swig_obj[0] = args;
33992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Close" "', expected argument " "1"" of type '" "wxClipboard *""'");
33995 }
33996 arg1 = reinterpret_cast< wxClipboard * >(argp1);
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 (arg1)->Close();
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 resultobj = SWIG_Py_Void();
34004 return resultobj;
34005 fail:
34006 return NULL;
34007 }
34008
34009
34010 SWIGINTERN PyObject *_wrap_Clipboard_IsOpened(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34011 PyObject *resultobj = 0;
34012 wxClipboard *arg1 = (wxClipboard *) 0 ;
34013 bool result;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 PyObject *swig_obj[1] ;
34017
34018 if (!args) SWIG_fail;
34019 swig_obj[0] = args;
34020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsOpened" "', expected argument " "1"" of type '" "wxClipboard const *""'");
34023 }
34024 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34025 {
34026 PyThreadState* __tstate = wxPyBeginAllowThreads();
34027 result = (bool)((wxClipboard const *)arg1)->IsOpened();
34028 wxPyEndAllowThreads(__tstate);
34029 if (PyErr_Occurred()) SWIG_fail;
34030 }
34031 {
34032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34033 }
34034 return resultobj;
34035 fail:
34036 return NULL;
34037 }
34038
34039
34040 SWIGINTERN PyObject *_wrap_Clipboard_AddData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34041 PyObject *resultobj = 0;
34042 wxClipboard *arg1 = (wxClipboard *) 0 ;
34043 wxDataObject *arg2 = (wxDataObject *) 0 ;
34044 bool result;
34045 void *argp1 = 0 ;
34046 int res1 = 0 ;
34047 int res2 = 0 ;
34048 PyObject * obj0 = 0 ;
34049 PyObject * obj1 = 0 ;
34050 char * kwnames[] = {
34051 (char *) "self",(char *) "data", NULL
34052 };
34053
34054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) SWIG_fail;
34055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34056 if (!SWIG_IsOK(res1)) {
34057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_AddData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34058 }
34059 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34060 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34061 if (!SWIG_IsOK(res2)) {
34062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_AddData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34063 }
34064 {
34065 PyThreadState* __tstate = wxPyBeginAllowThreads();
34066 result = (bool)(arg1)->AddData(arg2);
34067 wxPyEndAllowThreads(__tstate);
34068 if (PyErr_Occurred()) SWIG_fail;
34069 }
34070 {
34071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34072 }
34073 return resultobj;
34074 fail:
34075 return NULL;
34076 }
34077
34078
34079 SWIGINTERN PyObject *_wrap_Clipboard_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34080 PyObject *resultobj = 0;
34081 wxClipboard *arg1 = (wxClipboard *) 0 ;
34082 wxDataObject *arg2 = (wxDataObject *) 0 ;
34083 bool result;
34084 void *argp1 = 0 ;
34085 int res1 = 0 ;
34086 int res2 = 0 ;
34087 PyObject * obj0 = 0 ;
34088 PyObject * obj1 = 0 ;
34089 char * kwnames[] = {
34090 (char *) "self",(char *) "data", NULL
34091 };
34092
34093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
34094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34095 if (!SWIG_IsOK(res1)) {
34096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_SetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34097 }
34098 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34099 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxDataObject, SWIG_POINTER_DISOWN | 0 );
34100 if (!SWIG_IsOK(res2)) {
34101 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_SetData" "', expected argument " "2"" of type '" "wxDataObject *""'");
34102 }
34103 {
34104 PyThreadState* __tstate = wxPyBeginAllowThreads();
34105 result = (bool)(arg1)->SetData(arg2);
34106 wxPyEndAllowThreads(__tstate);
34107 if (PyErr_Occurred()) SWIG_fail;
34108 }
34109 {
34110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34111 }
34112 return resultobj;
34113 fail:
34114 return NULL;
34115 }
34116
34117
34118 SWIGINTERN PyObject *_wrap_Clipboard_IsSupported(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34119 PyObject *resultobj = 0;
34120 wxClipboard *arg1 = (wxClipboard *) 0 ;
34121 wxDataFormat *arg2 = 0 ;
34122 bool result;
34123 void *argp1 = 0 ;
34124 int res1 = 0 ;
34125 void *argp2 = 0 ;
34126 int res2 = 0 ;
34127 PyObject * obj0 = 0 ;
34128 PyObject * obj1 = 0 ;
34129 char * kwnames[] = {
34130 (char *) "self",(char *) "format", NULL
34131 };
34132
34133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) SWIG_fail;
34134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34135 if (!SWIG_IsOK(res1)) {
34136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_IsSupported" "', expected argument " "1"" of type '" "wxClipboard *""'");
34137 }
34138 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34139 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataFormat, 0 | 0);
34140 if (!SWIG_IsOK(res2)) {
34141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34142 }
34143 if (!argp2) {
34144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_IsSupported" "', expected argument " "2"" of type '" "wxDataFormat const &""'");
34145 }
34146 arg2 = reinterpret_cast< wxDataFormat * >(argp2);
34147 {
34148 PyThreadState* __tstate = wxPyBeginAllowThreads();
34149 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
34150 wxPyEndAllowThreads(__tstate);
34151 if (PyErr_Occurred()) SWIG_fail;
34152 }
34153 {
34154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34155 }
34156 return resultobj;
34157 fail:
34158 return NULL;
34159 }
34160
34161
34162 SWIGINTERN PyObject *_wrap_Clipboard_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34163 PyObject *resultobj = 0;
34164 wxClipboard *arg1 = (wxClipboard *) 0 ;
34165 wxDataObject *arg2 = 0 ;
34166 bool result;
34167 void *argp1 = 0 ;
34168 int res1 = 0 ;
34169 void *argp2 = 0 ;
34170 int res2 = 0 ;
34171 PyObject * obj0 = 0 ;
34172 PyObject * obj1 = 0 ;
34173 char * kwnames[] = {
34174 (char *) "self",(char *) "data", NULL
34175 };
34176
34177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) SWIG_fail;
34178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34179 if (!SWIG_IsOK(res1)) {
34180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_GetData" "', expected argument " "1"" of type '" "wxClipboard *""'");
34181 }
34182 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34183 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDataObject, 0 );
34184 if (!SWIG_IsOK(res2)) {
34185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34186 }
34187 if (!argp2) {
34188 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Clipboard_GetData" "', expected argument " "2"" of type '" "wxDataObject &""'");
34189 }
34190 arg2 = reinterpret_cast< wxDataObject * >(argp2);
34191 {
34192 PyThreadState* __tstate = wxPyBeginAllowThreads();
34193 result = (bool)(arg1)->GetData(*arg2);
34194 wxPyEndAllowThreads(__tstate);
34195 if (PyErr_Occurred()) SWIG_fail;
34196 }
34197 {
34198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34199 }
34200 return resultobj;
34201 fail:
34202 return NULL;
34203 }
34204
34205
34206 SWIGINTERN PyObject *_wrap_Clipboard_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34207 PyObject *resultobj = 0;
34208 wxClipboard *arg1 = (wxClipboard *) 0 ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 PyObject *swig_obj[1] ;
34212
34213 if (!args) SWIG_fail;
34214 swig_obj[0] = args;
34215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34216 if (!SWIG_IsOK(res1)) {
34217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Clear" "', expected argument " "1"" of type '" "wxClipboard *""'");
34218 }
34219 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34220 {
34221 PyThreadState* __tstate = wxPyBeginAllowThreads();
34222 (arg1)->Clear();
34223 wxPyEndAllowThreads(__tstate);
34224 if (PyErr_Occurred()) SWIG_fail;
34225 }
34226 resultobj = SWIG_Py_Void();
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 SWIGINTERN PyObject *_wrap_Clipboard_Flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34234 PyObject *resultobj = 0;
34235 wxClipboard *arg1 = (wxClipboard *) 0 ;
34236 bool result;
34237 void *argp1 = 0 ;
34238 int res1 = 0 ;
34239 PyObject *swig_obj[1] ;
34240
34241 if (!args) SWIG_fail;
34242 swig_obj[0] = args;
34243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34244 if (!SWIG_IsOK(res1)) {
34245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_Flush" "', expected argument " "1"" of type '" "wxClipboard *""'");
34246 }
34247 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34248 {
34249 PyThreadState* __tstate = wxPyBeginAllowThreads();
34250 result = (bool)(arg1)->Flush();
34251 wxPyEndAllowThreads(__tstate);
34252 if (PyErr_Occurred()) SWIG_fail;
34253 }
34254 {
34255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34256 }
34257 return resultobj;
34258 fail:
34259 return NULL;
34260 }
34261
34262
34263 SWIGINTERN PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34264 PyObject *resultobj = 0;
34265 wxClipboard *arg1 = (wxClipboard *) 0 ;
34266 bool arg2 = (bool) true ;
34267 void *argp1 = 0 ;
34268 int res1 = 0 ;
34269 bool val2 ;
34270 int ecode2 = 0 ;
34271 PyObject * obj0 = 0 ;
34272 PyObject * obj1 = 0 ;
34273 char * kwnames[] = {
34274 (char *) "self",(char *) "primary", NULL
34275 };
34276
34277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) SWIG_fail;
34278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxClipboard, 0 | 0 );
34279 if (!SWIG_IsOK(res1)) {
34280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "1"" of type '" "wxClipboard *""'");
34281 }
34282 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34283 if (obj1) {
34284 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34285 if (!SWIG_IsOK(ecode2)) {
34286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Clipboard_UsePrimarySelection" "', expected argument " "2"" of type '" "bool""'");
34287 }
34288 arg2 = static_cast< bool >(val2);
34289 }
34290 {
34291 PyThreadState* __tstate = wxPyBeginAllowThreads();
34292 (arg1)->UsePrimarySelection(arg2);
34293 wxPyEndAllowThreads(__tstate);
34294 if (PyErr_Occurred()) SWIG_fail;
34295 }
34296 resultobj = SWIG_Py_Void();
34297 return resultobj;
34298 fail:
34299 return NULL;
34300 }
34301
34302
34303 SWIGINTERN PyObject *_wrap_Clipboard_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34304 PyObject *resultobj = 0;
34305 wxClipboard *result = 0 ;
34306
34307 if (!SWIG_Python_UnpackTuple(args,"Clipboard_Get",0,0,0)) SWIG_fail;
34308 {
34309 PyThreadState* __tstate = wxPyBeginAllowThreads();
34310 result = (wxClipboard *)wxClipboard::Get();
34311 wxPyEndAllowThreads(__tstate);
34312 if (PyErr_Occurred()) SWIG_fail;
34313 }
34314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboard, 0 | 0 );
34315 return resultobj;
34316 fail:
34317 return NULL;
34318 }
34319
34320
34321 SWIGINTERN PyObject *Clipboard_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34322 PyObject *obj;
34323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34324 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboard, SWIG_NewClientData(obj));
34325 return SWIG_Py_Void();
34326 }
34327
34328 SWIGINTERN PyObject *Clipboard_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34329 return SWIG_Python_InitShadowInstance(args);
34330 }
34331
34332 SWIGINTERN PyObject *_wrap_new_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34333 PyObject *resultobj = 0;
34334 wxClipboard *arg1 = (wxClipboard *) NULL ;
34335 wxClipboardLocker *result = 0 ;
34336 void *argp1 = 0 ;
34337 int res1 = 0 ;
34338 PyObject * obj0 = 0 ;
34339 char * kwnames[] = {
34340 (char *) "clipboard", NULL
34341 };
34342
34343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) SWIG_fail;
34344 if (obj0) {
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 '" "new_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboard *""'");
34348 }
34349 arg1 = reinterpret_cast< wxClipboard * >(argp1);
34350 }
34351 {
34352 PyThreadState* __tstate = wxPyBeginAllowThreads();
34353 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
34354 wxPyEndAllowThreads(__tstate);
34355 if (PyErr_Occurred()) SWIG_fail;
34356 }
34357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_NEW | 0 );
34358 return resultobj;
34359 fail:
34360 return NULL;
34361 }
34362
34363
34364 SWIGINTERN PyObject *_wrap_delete_ClipboardLocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34365 PyObject *resultobj = 0;
34366 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34367 void *argp1 = 0 ;
34368 int res1 = 0 ;
34369 PyObject *swig_obj[1] ;
34370
34371 if (!args) SWIG_fail;
34372 swig_obj[0] = args;
34373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_DISOWN | 0 );
34374 if (!SWIG_IsOK(res1)) {
34375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClipboardLocker" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34376 }
34377 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34378 {
34379 PyThreadState* __tstate = wxPyBeginAllowThreads();
34380 delete arg1;
34381
34382 wxPyEndAllowThreads(__tstate);
34383 if (PyErr_Occurred()) SWIG_fail;
34384 }
34385 resultobj = SWIG_Py_Void();
34386 return resultobj;
34387 fail:
34388 return NULL;
34389 }
34390
34391
34392 SWIGINTERN PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34393 PyObject *resultobj = 0;
34394 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
34395 bool result;
34396 void *argp1 = 0 ;
34397 int res1 = 0 ;
34398 PyObject *swig_obj[1] ;
34399
34400 if (!args) SWIG_fail;
34401 swig_obj[0] = args;
34402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxClipboardLocker, 0 | 0 );
34403 if (!SWIG_IsOK(res1)) {
34404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClipboardLocker___nonzero__" "', expected argument " "1"" of type '" "wxClipboardLocker *""'");
34405 }
34406 arg1 = reinterpret_cast< wxClipboardLocker * >(argp1);
34407 {
34408 PyThreadState* __tstate = wxPyBeginAllowThreads();
34409 result = (bool)wxClipboardLocker___nonzero__(arg1);
34410 wxPyEndAllowThreads(__tstate);
34411 if (PyErr_Occurred()) SWIG_fail;
34412 }
34413 {
34414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34415 }
34416 return resultobj;
34417 fail:
34418 return NULL;
34419 }
34420
34421
34422 SWIGINTERN PyObject *ClipboardLocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34423 PyObject *obj;
34424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34425 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardLocker, SWIG_NewClientData(obj));
34426 return SWIG_Py_Void();
34427 }
34428
34429 SWIGINTERN PyObject *ClipboardLocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34430 return SWIG_Python_InitShadowInstance(args);
34431 }
34432
34433 SWIGINTERN PyObject *_wrap_new_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34434 PyObject *resultobj = 0;
34435 int arg1 = (int) 0 ;
34436 int arg2 = (int) 0 ;
34437 int arg3 = (int) 0 ;
34438 int arg4 = (int) 0 ;
34439 wxVideoMode *result = 0 ;
34440 int val1 ;
34441 int ecode1 = 0 ;
34442 int val2 ;
34443 int ecode2 = 0 ;
34444 int val3 ;
34445 int ecode3 = 0 ;
34446 int val4 ;
34447 int ecode4 = 0 ;
34448 PyObject * obj0 = 0 ;
34449 PyObject * obj1 = 0 ;
34450 PyObject * obj2 = 0 ;
34451 PyObject * obj3 = 0 ;
34452 char * kwnames[] = {
34453 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
34454 };
34455
34456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34457 if (obj0) {
34458 ecode1 = SWIG_AsVal_int(obj0, &val1);
34459 if (!SWIG_IsOK(ecode1)) {
34460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VideoMode" "', expected argument " "1"" of type '" "int""'");
34461 }
34462 arg1 = static_cast< int >(val1);
34463 }
34464 if (obj1) {
34465 ecode2 = SWIG_AsVal_int(obj1, &val2);
34466 if (!SWIG_IsOK(ecode2)) {
34467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VideoMode" "', expected argument " "2"" of type '" "int""'");
34468 }
34469 arg2 = static_cast< int >(val2);
34470 }
34471 if (obj2) {
34472 ecode3 = SWIG_AsVal_int(obj2, &val3);
34473 if (!SWIG_IsOK(ecode3)) {
34474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VideoMode" "', expected argument " "3"" of type '" "int""'");
34475 }
34476 arg3 = static_cast< int >(val3);
34477 }
34478 if (obj3) {
34479 ecode4 = SWIG_AsVal_int(obj3, &val4);
34480 if (!SWIG_IsOK(ecode4)) {
34481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VideoMode" "', expected argument " "4"" of type '" "int""'");
34482 }
34483 arg4 = static_cast< int >(val4);
34484 }
34485 {
34486 PyThreadState* __tstate = wxPyBeginAllowThreads();
34487 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
34488 wxPyEndAllowThreads(__tstate);
34489 if (PyErr_Occurred()) SWIG_fail;
34490 }
34491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_NEW | 0 );
34492 return resultobj;
34493 fail:
34494 return NULL;
34495 }
34496
34497
34498 SWIGINTERN PyObject *_wrap_delete_VideoMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34499 PyObject *resultobj = 0;
34500 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34501 void *argp1 = 0 ;
34502 int res1 = 0 ;
34503 PyObject *swig_obj[1] ;
34504
34505 if (!args) SWIG_fail;
34506 swig_obj[0] = args;
34507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, SWIG_POINTER_DISOWN | 0 );
34508 if (!SWIG_IsOK(res1)) {
34509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VideoMode" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34510 }
34511 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34512 {
34513 PyThreadState* __tstate = wxPyBeginAllowThreads();
34514 delete arg1;
34515
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_Py_Void();
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_VideoMode_Matches(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34527 PyObject *resultobj = 0;
34528 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34529 wxVideoMode *arg2 = 0 ;
34530 bool result;
34531 void *argp1 = 0 ;
34532 int res1 = 0 ;
34533 void *argp2 = 0 ;
34534 int res2 = 0 ;
34535 PyObject * obj0 = 0 ;
34536 PyObject * obj1 = 0 ;
34537 char * kwnames[] = {
34538 (char *) "self",(char *) "other", NULL
34539 };
34540
34541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) SWIG_fail;
34542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34543 if (!SWIG_IsOK(res1)) {
34544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_Matches" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34545 }
34546 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34547 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
34548 if (!SWIG_IsOK(res2)) {
34549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34550 }
34551 if (!argp2) {
34552 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VideoMode_Matches" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
34553 }
34554 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34555 {
34556 PyThreadState* __tstate = wxPyBeginAllowThreads();
34557 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 {
34562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34563 }
34564 return resultobj;
34565 fail:
34566 return NULL;
34567 }
34568
34569
34570 SWIGINTERN PyObject *_wrap_VideoMode_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34571 PyObject *resultobj = 0;
34572 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34573 int result;
34574 void *argp1 = 0 ;
34575 int res1 = 0 ;
34576 PyObject *swig_obj[1] ;
34577
34578 if (!args) SWIG_fail;
34579 swig_obj[0] = args;
34580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34581 if (!SWIG_IsOK(res1)) {
34582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetWidth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34583 }
34584 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34585 {
34586 PyThreadState* __tstate = wxPyBeginAllowThreads();
34587 result = (int)((wxVideoMode const *)arg1)->GetWidth();
34588 wxPyEndAllowThreads(__tstate);
34589 if (PyErr_Occurred()) SWIG_fail;
34590 }
34591 resultobj = SWIG_From_int(static_cast< int >(result));
34592 return resultobj;
34593 fail:
34594 return NULL;
34595 }
34596
34597
34598 SWIGINTERN PyObject *_wrap_VideoMode_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34599 PyObject *resultobj = 0;
34600 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34601 int result;
34602 void *argp1 = 0 ;
34603 int res1 = 0 ;
34604 PyObject *swig_obj[1] ;
34605
34606 if (!args) SWIG_fail;
34607 swig_obj[0] = args;
34608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34609 if (!SWIG_IsOK(res1)) {
34610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetHeight" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34611 }
34612 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34613 {
34614 PyThreadState* __tstate = wxPyBeginAllowThreads();
34615 result = (int)((wxVideoMode const *)arg1)->GetHeight();
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 resultobj = SWIG_From_int(static_cast< int >(result));
34620 return resultobj;
34621 fail:
34622 return NULL;
34623 }
34624
34625
34626 SWIGINTERN PyObject *_wrap_VideoMode_GetDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34627 PyObject *resultobj = 0;
34628 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34629 int result;
34630 void *argp1 = 0 ;
34631 int res1 = 0 ;
34632 PyObject *swig_obj[1] ;
34633
34634 if (!args) SWIG_fail;
34635 swig_obj[0] = args;
34636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34637 if (!SWIG_IsOK(res1)) {
34638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_GetDepth" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34639 }
34640 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34641 {
34642 PyThreadState* __tstate = wxPyBeginAllowThreads();
34643 result = (int)((wxVideoMode const *)arg1)->GetDepth();
34644 wxPyEndAllowThreads(__tstate);
34645 if (PyErr_Occurred()) SWIG_fail;
34646 }
34647 resultobj = SWIG_From_int(static_cast< int >(result));
34648 return resultobj;
34649 fail:
34650 return NULL;
34651 }
34652
34653
34654 SWIGINTERN PyObject *_wrap_VideoMode_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34655 PyObject *resultobj = 0;
34656 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34657 bool result;
34658 void *argp1 = 0 ;
34659 int res1 = 0 ;
34660 PyObject *swig_obj[1] ;
34661
34662 if (!args) SWIG_fail;
34663 swig_obj[0] = args;
34664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34665 if (!SWIG_IsOK(res1)) {
34666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_IsOk" "', expected argument " "1"" of type '" "wxVideoMode const *""'");
34667 }
34668 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34669 {
34670 PyThreadState* __tstate = wxPyBeginAllowThreads();
34671 result = (bool)((wxVideoMode const *)arg1)->IsOk();
34672 wxPyEndAllowThreads(__tstate);
34673 if (PyErr_Occurred()) SWIG_fail;
34674 }
34675 {
34676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34677 }
34678 return resultobj;
34679 fail:
34680 return NULL;
34681 }
34682
34683
34684 SWIGINTERN PyObject *_wrap_VideoMode___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34685 PyObject *resultobj = 0;
34686 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34687 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34688 bool result;
34689 void *argp1 = 0 ;
34690 int res1 = 0 ;
34691 void *argp2 = 0 ;
34692 int res2 = 0 ;
34693 PyObject * obj0 = 0 ;
34694 PyObject * obj1 = 0 ;
34695 char * kwnames[] = {
34696 (char *) "self",(char *) "other", NULL
34697 };
34698
34699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
34700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34701 if (!SWIG_IsOK(res1)) {
34702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___eq__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34703 }
34704 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34706 if (!SWIG_IsOK(res2)) {
34707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___eq__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34708 }
34709 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34710 {
34711 PyThreadState* __tstate = wxPyBeginAllowThreads();
34712 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
34713 wxPyEndAllowThreads(__tstate);
34714 if (PyErr_Occurred()) SWIG_fail;
34715 }
34716 {
34717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34718 }
34719 return resultobj;
34720 fail:
34721 return NULL;
34722 }
34723
34724
34725 SWIGINTERN PyObject *_wrap_VideoMode___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34726 PyObject *resultobj = 0;
34727 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34728 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
34729 bool result;
34730 void *argp1 = 0 ;
34731 int res1 = 0 ;
34732 void *argp2 = 0 ;
34733 int res2 = 0 ;
34734 PyObject * obj0 = 0 ;
34735 PyObject * obj1 = 0 ;
34736 char * kwnames[] = {
34737 (char *) "self",(char *) "other", NULL
34738 };
34739
34740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
34741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34742 if (!SWIG_IsOK(res1)) {
34743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode___ne__" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34744 }
34745 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34747 if (!SWIG_IsOK(res2)) {
34748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VideoMode___ne__" "', expected argument " "2"" of type '" "wxVideoMode const *""'");
34749 }
34750 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
34751 {
34752 PyThreadState* __tstate = wxPyBeginAllowThreads();
34753 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
34754 wxPyEndAllowThreads(__tstate);
34755 if (PyErr_Occurred()) SWIG_fail;
34756 }
34757 {
34758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34759 }
34760 return resultobj;
34761 fail:
34762 return NULL;
34763 }
34764
34765
34766 SWIGINTERN PyObject *_wrap_VideoMode_w_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34767 PyObject *resultobj = 0;
34768 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34769 int arg2 ;
34770 void *argp1 = 0 ;
34771 int res1 = 0 ;
34772 int val2 ;
34773 int ecode2 = 0 ;
34774 PyObject *swig_obj[2] ;
34775
34776 if (!SWIG_Python_UnpackTuple(args,"VideoMode_w_set",2,2,swig_obj)) SWIG_fail;
34777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34778 if (!SWIG_IsOK(res1)) {
34779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34780 }
34781 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34782 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34783 if (!SWIG_IsOK(ecode2)) {
34784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_w_set" "', expected argument " "2"" of type '" "int""'");
34785 }
34786 arg2 = static_cast< int >(val2);
34787 if (arg1) (arg1)->w = arg2;
34788
34789 resultobj = SWIG_Py_Void();
34790 return resultobj;
34791 fail:
34792 return NULL;
34793 }
34794
34795
34796 SWIGINTERN PyObject *_wrap_VideoMode_w_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34797 PyObject *resultobj = 0;
34798 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34799 int result;
34800 void *argp1 = 0 ;
34801 int res1 = 0 ;
34802 PyObject *swig_obj[1] ;
34803
34804 if (!args) SWIG_fail;
34805 swig_obj[0] = args;
34806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34807 if (!SWIG_IsOK(res1)) {
34808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_w_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34809 }
34810 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34811 result = (int) ((arg1)->w);
34812 resultobj = SWIG_From_int(static_cast< int >(result));
34813 return resultobj;
34814 fail:
34815 return NULL;
34816 }
34817
34818
34819 SWIGINTERN PyObject *_wrap_VideoMode_h_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34820 PyObject *resultobj = 0;
34821 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34822 int arg2 ;
34823 void *argp1 = 0 ;
34824 int res1 = 0 ;
34825 int val2 ;
34826 int ecode2 = 0 ;
34827 PyObject *swig_obj[2] ;
34828
34829 if (!SWIG_Python_UnpackTuple(args,"VideoMode_h_set",2,2,swig_obj)) SWIG_fail;
34830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34831 if (!SWIG_IsOK(res1)) {
34832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34833 }
34834 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34835 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34836 if (!SWIG_IsOK(ecode2)) {
34837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_h_set" "', expected argument " "2"" of type '" "int""'");
34838 }
34839 arg2 = static_cast< int >(val2);
34840 if (arg1) (arg1)->h = arg2;
34841
34842 resultobj = SWIG_Py_Void();
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_VideoMode_h_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34850 PyObject *resultobj = 0;
34851 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34852 int result;
34853 void *argp1 = 0 ;
34854 int res1 = 0 ;
34855 PyObject *swig_obj[1] ;
34856
34857 if (!args) SWIG_fail;
34858 swig_obj[0] = args;
34859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34860 if (!SWIG_IsOK(res1)) {
34861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_h_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34862 }
34863 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34864 result = (int) ((arg1)->h);
34865 resultobj = SWIG_From_int(static_cast< int >(result));
34866 return resultobj;
34867 fail:
34868 return NULL;
34869 }
34870
34871
34872 SWIGINTERN PyObject *_wrap_VideoMode_bpp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34873 PyObject *resultobj = 0;
34874 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34875 int arg2 ;
34876 void *argp1 = 0 ;
34877 int res1 = 0 ;
34878 int val2 ;
34879 int ecode2 = 0 ;
34880 PyObject *swig_obj[2] ;
34881
34882 if (!SWIG_Python_UnpackTuple(args,"VideoMode_bpp_set",2,2,swig_obj)) SWIG_fail;
34883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34884 if (!SWIG_IsOK(res1)) {
34885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34886 }
34887 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34888 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34889 if (!SWIG_IsOK(ecode2)) {
34890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_bpp_set" "', expected argument " "2"" of type '" "int""'");
34891 }
34892 arg2 = static_cast< int >(val2);
34893 if (arg1) (arg1)->bpp = arg2;
34894
34895 resultobj = SWIG_Py_Void();
34896 return resultobj;
34897 fail:
34898 return NULL;
34899 }
34900
34901
34902 SWIGINTERN PyObject *_wrap_VideoMode_bpp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34903 PyObject *resultobj = 0;
34904 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34905 int result;
34906 void *argp1 = 0 ;
34907 int res1 = 0 ;
34908 PyObject *swig_obj[1] ;
34909
34910 if (!args) SWIG_fail;
34911 swig_obj[0] = args;
34912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34913 if (!SWIG_IsOK(res1)) {
34914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_bpp_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34915 }
34916 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34917 result = (int) ((arg1)->bpp);
34918 resultobj = SWIG_From_int(static_cast< int >(result));
34919 return resultobj;
34920 fail:
34921 return NULL;
34922 }
34923
34924
34925 SWIGINTERN PyObject *_wrap_VideoMode_refresh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34926 PyObject *resultobj = 0;
34927 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34928 int arg2 ;
34929 void *argp1 = 0 ;
34930 int res1 = 0 ;
34931 int val2 ;
34932 int ecode2 = 0 ;
34933 PyObject *swig_obj[2] ;
34934
34935 if (!SWIG_Python_UnpackTuple(args,"VideoMode_refresh_set",2,2,swig_obj)) SWIG_fail;
34936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34937 if (!SWIG_IsOK(res1)) {
34938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_set" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34939 }
34940 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34941 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
34942 if (!SWIG_IsOK(ecode2)) {
34943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VideoMode_refresh_set" "', expected argument " "2"" of type '" "int""'");
34944 }
34945 arg2 = static_cast< int >(val2);
34946 if (arg1) (arg1)->refresh = arg2;
34947
34948 resultobj = SWIG_Py_Void();
34949 return resultobj;
34950 fail:
34951 return NULL;
34952 }
34953
34954
34955 SWIGINTERN PyObject *_wrap_VideoMode_refresh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34956 PyObject *resultobj = 0;
34957 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
34958 int result;
34959 void *argp1 = 0 ;
34960 int res1 = 0 ;
34961 PyObject *swig_obj[1] ;
34962
34963 if (!args) SWIG_fail;
34964 swig_obj[0] = args;
34965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVideoMode, 0 | 0 );
34966 if (!SWIG_IsOK(res1)) {
34967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VideoMode_refresh_get" "', expected argument " "1"" of type '" "wxVideoMode *""'");
34968 }
34969 arg1 = reinterpret_cast< wxVideoMode * >(argp1);
34970 result = (int) ((arg1)->refresh);
34971 resultobj = SWIG_From_int(static_cast< int >(result));
34972 return resultobj;
34973 fail:
34974 return NULL;
34975 }
34976
34977
34978 SWIGINTERN PyObject *VideoMode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34979 PyObject *obj;
34980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
34981 SWIG_TypeNewClientData(SWIGTYPE_p_wxVideoMode, SWIG_NewClientData(obj));
34982 return SWIG_Py_Void();
34983 }
34984
34985 SWIGINTERN PyObject *VideoMode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34986 return SWIG_Python_InitShadowInstance(args);
34987 }
34988
34989 SWIGINTERN int DefaultVideoMode_set(PyObject *) {
34990 SWIG_Error(SWIG_AttributeError,"Variable DefaultVideoMode is read-only.");
34991 return 1;
34992 }
34993
34994
34995 SWIGINTERN PyObject *DefaultVideoMode_get(void) {
34996 PyObject *pyobj = 0;
34997
34998 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0 );
34999 return pyobj;
35000 }
35001
35002
35003 SWIGINTERN PyObject *_wrap_new_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35004 PyObject *resultobj = 0;
35005 size_t arg1 = (size_t) 0 ;
35006 wxDisplay *result = 0 ;
35007 size_t val1 ;
35008 int ecode1 = 0 ;
35009 PyObject * obj0 = 0 ;
35010 char * kwnames[] = {
35011 (char *) "index", NULL
35012 };
35013
35014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) SWIG_fail;
35015 if (obj0) {
35016 ecode1 = SWIG_AsVal_size_t(obj0, &val1);
35017 if (!SWIG_IsOK(ecode1)) {
35018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Display" "', expected argument " "1"" of type '" "size_t""'");
35019 }
35020 arg1 = static_cast< size_t >(val1);
35021 }
35022 {
35023 PyThreadState* __tstate = wxPyBeginAllowThreads();
35024 result = (wxDisplay *)new wxDisplay(arg1);
35025 wxPyEndAllowThreads(__tstate);
35026 if (PyErr_Occurred()) SWIG_fail;
35027 }
35028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplay, SWIG_POINTER_NEW | 0 );
35029 return resultobj;
35030 fail:
35031 return NULL;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_delete_Display(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35036 PyObject *resultobj = 0;
35037 wxDisplay *arg1 = (wxDisplay *) 0 ;
35038 void *argp1 = 0 ;
35039 int res1 = 0 ;
35040 PyObject *swig_obj[1] ;
35041
35042 if (!args) SWIG_fail;
35043 swig_obj[0] = args;
35044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, SWIG_POINTER_DISOWN | 0 );
35045 if (!SWIG_IsOK(res1)) {
35046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Display" "', expected argument " "1"" of type '" "wxDisplay *""'");
35047 }
35048 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35049 {
35050 PyThreadState* __tstate = wxPyBeginAllowThreads();
35051 delete arg1;
35052
35053 wxPyEndAllowThreads(__tstate);
35054 if (PyErr_Occurred()) SWIG_fail;
35055 }
35056 resultobj = SWIG_Py_Void();
35057 return resultobj;
35058 fail:
35059 return NULL;
35060 }
35061
35062
35063 SWIGINTERN PyObject *_wrap_Display_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35064 PyObject *resultobj = 0;
35065 size_t result;
35066
35067 if (!SWIG_Python_UnpackTuple(args,"Display_GetCount",0,0,0)) SWIG_fail;
35068 {
35069 PyThreadState* __tstate = wxPyBeginAllowThreads();
35070 result = (size_t)wxDisplay::GetCount();
35071 wxPyEndAllowThreads(__tstate);
35072 if (PyErr_Occurred()) SWIG_fail;
35073 }
35074 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
35075 return resultobj;
35076 fail:
35077 return NULL;
35078 }
35079
35080
35081 SWIGINTERN PyObject *_wrap_Display_GetFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35082 PyObject *resultobj = 0;
35083 wxPoint *arg1 = 0 ;
35084 int result;
35085 wxPoint temp1 ;
35086 PyObject * obj0 = 0 ;
35087 char * kwnames[] = {
35088 (char *) "pt", NULL
35089 };
35090
35091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) SWIG_fail;
35092 {
35093 arg1 = &temp1;
35094 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
35095 }
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
35099 wxPyEndAllowThreads(__tstate);
35100 if (PyErr_Occurred()) SWIG_fail;
35101 }
35102 resultobj = SWIG_From_int(static_cast< int >(result));
35103 return resultobj;
35104 fail:
35105 return NULL;
35106 }
35107
35108
35109 SWIGINTERN PyObject *_wrap_Display_GetFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj = 0;
35111 wxWindow *arg1 = (wxWindow *) 0 ;
35112 int result;
35113 void *argp1 = 0 ;
35114 int res1 = 0 ;
35115 PyObject * obj0 = 0 ;
35116 char * kwnames[] = {
35117 (char *) "window", NULL
35118 };
35119
35120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) SWIG_fail;
35121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35122 if (!SWIG_IsOK(res1)) {
35123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
35124 }
35125 arg1 = reinterpret_cast< wxWindow * >(argp1);
35126 {
35127 PyThreadState* __tstate = wxPyBeginAllowThreads();
35128 result = (int)wxDisplay::GetFromWindow(arg1);
35129 wxPyEndAllowThreads(__tstate);
35130 if (PyErr_Occurred()) SWIG_fail;
35131 }
35132 resultobj = SWIG_From_int(static_cast< int >(result));
35133 return resultobj;
35134 fail:
35135 return NULL;
35136 }
35137
35138
35139 SWIGINTERN PyObject *_wrap_Display_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35140 PyObject *resultobj = 0;
35141 wxDisplay *arg1 = (wxDisplay *) 0 ;
35142 bool result;
35143 void *argp1 = 0 ;
35144 int res1 = 0 ;
35145 PyObject *swig_obj[1] ;
35146
35147 if (!args) SWIG_fail;
35148 swig_obj[0] = args;
35149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35150 if (!SWIG_IsOK(res1)) {
35151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsOk" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35152 }
35153 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35154 {
35155 PyThreadState* __tstate = wxPyBeginAllowThreads();
35156 result = (bool)((wxDisplay const *)arg1)->IsOk();
35157 wxPyEndAllowThreads(__tstate);
35158 if (PyErr_Occurred()) SWIG_fail;
35159 }
35160 {
35161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35162 }
35163 return resultobj;
35164 fail:
35165 return NULL;
35166 }
35167
35168
35169 SWIGINTERN PyObject *_wrap_Display_GetGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35170 PyObject *resultobj = 0;
35171 wxDisplay *arg1 = (wxDisplay *) 0 ;
35172 wxRect result;
35173 void *argp1 = 0 ;
35174 int res1 = 0 ;
35175 PyObject *swig_obj[1] ;
35176
35177 if (!args) SWIG_fail;
35178 swig_obj[0] = args;
35179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35180 if (!SWIG_IsOK(res1)) {
35181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetGeometry" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35182 }
35183 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35184 {
35185 PyThreadState* __tstate = wxPyBeginAllowThreads();
35186 result = ((wxDisplay const *)arg1)->GetGeometry();
35187 wxPyEndAllowThreads(__tstate);
35188 if (PyErr_Occurred()) SWIG_fail;
35189 }
35190 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35191 return resultobj;
35192 fail:
35193 return NULL;
35194 }
35195
35196
35197 SWIGINTERN PyObject *_wrap_Display_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35198 PyObject *resultobj = 0;
35199 wxDisplay *arg1 = (wxDisplay *) 0 ;
35200 wxString result;
35201 void *argp1 = 0 ;
35202 int res1 = 0 ;
35203 PyObject *swig_obj[1] ;
35204
35205 if (!args) SWIG_fail;
35206 swig_obj[0] = args;
35207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35208 if (!SWIG_IsOK(res1)) {
35209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetName" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35210 }
35211 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35212 {
35213 PyThreadState* __tstate = wxPyBeginAllowThreads();
35214 result = ((wxDisplay const *)arg1)->GetName();
35215 wxPyEndAllowThreads(__tstate);
35216 if (PyErr_Occurred()) SWIG_fail;
35217 }
35218 {
35219 #if wxUSE_UNICODE
35220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35221 #else
35222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35223 #endif
35224 }
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 SWIGINTERN PyObject *_wrap_Display_IsPrimary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35232 PyObject *resultobj = 0;
35233 wxDisplay *arg1 = (wxDisplay *) 0 ;
35234 bool result;
35235 void *argp1 = 0 ;
35236 int res1 = 0 ;
35237 PyObject *swig_obj[1] ;
35238
35239 if (!args) SWIG_fail;
35240 swig_obj[0] = args;
35241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35242 if (!SWIG_IsOK(res1)) {
35243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_IsPrimary" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35244 }
35245 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35246 {
35247 PyThreadState* __tstate = wxPyBeginAllowThreads();
35248 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 {
35253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35254 }
35255 return resultobj;
35256 fail:
35257 return NULL;
35258 }
35259
35260
35261 SWIGINTERN PyObject *_wrap_Display_GetModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35262 PyObject *resultobj = 0;
35263 wxDisplay *arg1 = (wxDisplay *) 0 ;
35264 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35265 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35266 PyObject *result = 0 ;
35267 void *argp1 = 0 ;
35268 int res1 = 0 ;
35269 void *argp2 = 0 ;
35270 int res2 = 0 ;
35271 PyObject * obj0 = 0 ;
35272 PyObject * obj1 = 0 ;
35273 char * kwnames[] = {
35274 (char *) "self",(char *) "mode", NULL
35275 };
35276
35277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) SWIG_fail;
35278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35279 if (!SWIG_IsOK(res1)) {
35280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetModes" "', expected argument " "1"" of type '" "wxDisplay *""'");
35281 }
35282 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35283 if (obj1) {
35284 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35285 if (!SWIG_IsOK(res2)) {
35286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35287 }
35288 if (!argp2) {
35289 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_GetModes" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35290 }
35291 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35292 }
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
35296 wxPyEndAllowThreads(__tstate);
35297 if (PyErr_Occurred()) SWIG_fail;
35298 }
35299 resultobj = result;
35300 return resultobj;
35301 fail:
35302 return NULL;
35303 }
35304
35305
35306 SWIGINTERN PyObject *_wrap_Display_GetCurrentMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35307 PyObject *resultobj = 0;
35308 wxDisplay *arg1 = (wxDisplay *) 0 ;
35309 wxVideoMode result;
35310 void *argp1 = 0 ;
35311 int res1 = 0 ;
35312 PyObject *swig_obj[1] ;
35313
35314 if (!args) SWIG_fail;
35315 swig_obj[0] = args;
35316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35317 if (!SWIG_IsOK(res1)) {
35318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_GetCurrentMode" "', expected argument " "1"" of type '" "wxDisplay const *""'");
35319 }
35320 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 result = ((wxDisplay const *)arg1)->GetCurrentMode();
35324 wxPyEndAllowThreads(__tstate);
35325 if (PyErr_Occurred()) SWIG_fail;
35326 }
35327 resultobj = SWIG_NewPointerObj((new wxVideoMode(static_cast< const wxVideoMode& >(result))), SWIGTYPE_p_wxVideoMode, SWIG_POINTER_OWN | 0 );
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 SWIGINTERN PyObject *_wrap_Display_ChangeMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35335 PyObject *resultobj = 0;
35336 wxDisplay *arg1 = (wxDisplay *) 0 ;
35337 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
35338 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
35339 bool result;
35340 void *argp1 = 0 ;
35341 int res1 = 0 ;
35342 void *argp2 = 0 ;
35343 int res2 = 0 ;
35344 PyObject * obj0 = 0 ;
35345 PyObject * obj1 = 0 ;
35346 char * kwnames[] = {
35347 (char *) "self",(char *) "mode", NULL
35348 };
35349
35350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) SWIG_fail;
35351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35352 if (!SWIG_IsOK(res1)) {
35353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ChangeMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35354 }
35355 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35356 if (obj1) {
35357 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxVideoMode, 0 | 0);
35358 if (!SWIG_IsOK(res2)) {
35359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35360 }
35361 if (!argp2) {
35362 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Display_ChangeMode" "', expected argument " "2"" of type '" "wxVideoMode const &""'");
35363 }
35364 arg2 = reinterpret_cast< wxVideoMode * >(argp2);
35365 }
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 {
35373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35374 }
35375 return resultobj;
35376 fail:
35377 return NULL;
35378 }
35379
35380
35381 SWIGINTERN PyObject *_wrap_Display_ResetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35382 PyObject *resultobj = 0;
35383 wxDisplay *arg1 = (wxDisplay *) 0 ;
35384 void *argp1 = 0 ;
35385 int res1 = 0 ;
35386 PyObject *swig_obj[1] ;
35387
35388 if (!args) SWIG_fail;
35389 swig_obj[0] = args;
35390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDisplay, 0 | 0 );
35391 if (!SWIG_IsOK(res1)) {
35392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Display_ResetMode" "', expected argument " "1"" of type '" "wxDisplay *""'");
35393 }
35394 arg1 = reinterpret_cast< wxDisplay * >(argp1);
35395 {
35396 PyThreadState* __tstate = wxPyBeginAllowThreads();
35397 (arg1)->ResetMode();
35398 wxPyEndAllowThreads(__tstate);
35399 if (PyErr_Occurred()) SWIG_fail;
35400 }
35401 resultobj = SWIG_Py_Void();
35402 return resultobj;
35403 fail:
35404 return NULL;
35405 }
35406
35407
35408 SWIGINTERN PyObject *Display_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35409 PyObject *obj;
35410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35411 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplay, SWIG_NewClientData(obj));
35412 return SWIG_Py_Void();
35413 }
35414
35415 SWIGINTERN PyObject *Display_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35416 return SWIG_Python_InitShadowInstance(args);
35417 }
35418
35419 SWIGINTERN PyObject *_wrap_StandardPaths_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35420 PyObject *resultobj = 0;
35421 wxStandardPaths *result = 0 ;
35422
35423 if (!SWIG_Python_UnpackTuple(args,"StandardPaths_Get",0,0,0)) SWIG_fail;
35424 {
35425 PyThreadState* __tstate = wxPyBeginAllowThreads();
35426 result = (wxStandardPaths *)wxStandardPaths_Get();
35427 wxPyEndAllowThreads(__tstate);
35428 if (PyErr_Occurred()) SWIG_fail;
35429 }
35430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35431 return resultobj;
35432 fail:
35433 return NULL;
35434 }
35435
35436
35437 SWIGINTERN PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35438 PyObject *resultobj = 0;
35439 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35440 wxString result;
35441 void *argp1 = 0 ;
35442 int res1 = 0 ;
35443 PyObject *swig_obj[1] ;
35444
35445 if (!args) SWIG_fail;
35446 swig_obj[0] = args;
35447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35448 if (!SWIG_IsOK(res1)) {
35449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35450 }
35451 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35452 {
35453 PyThreadState* __tstate = wxPyBeginAllowThreads();
35454 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
35455 wxPyEndAllowThreads(__tstate);
35456 if (PyErr_Occurred()) SWIG_fail;
35457 }
35458 {
35459 #if wxUSE_UNICODE
35460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35461 #else
35462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35463 #endif
35464 }
35465 return resultobj;
35466 fail:
35467 return NULL;
35468 }
35469
35470
35471 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35472 PyObject *resultobj = 0;
35473 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35474 wxString result;
35475 void *argp1 = 0 ;
35476 int res1 = 0 ;
35477 PyObject *swig_obj[1] ;
35478
35479 if (!args) SWIG_fail;
35480 swig_obj[0] = args;
35481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserConfigDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35484 }
35485 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 {
35493 #if wxUSE_UNICODE
35494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35495 #else
35496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35497 #endif
35498 }
35499 return resultobj;
35500 fail:
35501 return NULL;
35502 }
35503
35504
35505 SWIGINTERN PyObject *_wrap_StandardPaths_GetDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35506 PyObject *resultobj = 0;
35507 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35508 wxString result;
35509 void *argp1 = 0 ;
35510 int res1 = 0 ;
35511 PyObject *swig_obj[1] ;
35512
35513 if (!args) SWIG_fail;
35514 swig_obj[0] = args;
35515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35516 if (!SWIG_IsOK(res1)) {
35517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35518 }
35519 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35520 {
35521 PyThreadState* __tstate = wxPyBeginAllowThreads();
35522 result = ((wxStandardPaths const *)arg1)->GetDataDir();
35523 wxPyEndAllowThreads(__tstate);
35524 if (PyErr_Occurred()) SWIG_fail;
35525 }
35526 {
35527 #if wxUSE_UNICODE
35528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35529 #else
35530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35531 #endif
35532 }
35533 return resultobj;
35534 fail:
35535 return NULL;
35536 }
35537
35538
35539 SWIGINTERN PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35540 PyObject *resultobj = 0;
35541 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35542 wxString result;
35543 void *argp1 = 0 ;
35544 int res1 = 0 ;
35545 PyObject *swig_obj[1] ;
35546
35547 if (!args) SWIG_fail;
35548 swig_obj[0] = args;
35549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35550 if (!SWIG_IsOK(res1)) {
35551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35552 }
35553 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35554 {
35555 PyThreadState* __tstate = wxPyBeginAllowThreads();
35556 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
35557 wxPyEndAllowThreads(__tstate);
35558 if (PyErr_Occurred()) SWIG_fail;
35559 }
35560 {
35561 #if wxUSE_UNICODE
35562 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35563 #else
35564 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35565 #endif
35566 }
35567 return resultobj;
35568 fail:
35569 return NULL;
35570 }
35571
35572
35573 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35574 PyObject *resultobj = 0;
35575 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35576 wxString result;
35577 void *argp1 = 0 ;
35578 int res1 = 0 ;
35579 PyObject *swig_obj[1] ;
35580
35581 if (!args) SWIG_fail;
35582 swig_obj[0] = args;
35583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35584 if (!SWIG_IsOK(res1)) {
35585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35586 }
35587 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35588 {
35589 PyThreadState* __tstate = wxPyBeginAllowThreads();
35590 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
35591 wxPyEndAllowThreads(__tstate);
35592 if (PyErr_Occurred()) SWIG_fail;
35593 }
35594 {
35595 #if wxUSE_UNICODE
35596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35597 #else
35598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35599 #endif
35600 }
35601 return resultobj;
35602 fail:
35603 return NULL;
35604 }
35605
35606
35607 SWIGINTERN PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35608 PyObject *resultobj = 0;
35609 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35610 wxString result;
35611 void *argp1 = 0 ;
35612 int res1 = 0 ;
35613 PyObject *swig_obj[1] ;
35614
35615 if (!args) SWIG_fail;
35616 swig_obj[0] = args;
35617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35618 if (!SWIG_IsOK(res1)) {
35619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetUserLocalDataDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35620 }
35621 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35622 {
35623 PyThreadState* __tstate = wxPyBeginAllowThreads();
35624 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
35625 wxPyEndAllowThreads(__tstate);
35626 if (PyErr_Occurred()) SWIG_fail;
35627 }
35628 {
35629 #if wxUSE_UNICODE
35630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35631 #else
35632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35633 #endif
35634 }
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 SWIGINTERN PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35642 PyObject *resultobj = 0;
35643 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35644 wxString result;
35645 void *argp1 = 0 ;
35646 int res1 = 0 ;
35647 PyObject *swig_obj[1] ;
35648
35649 if (!args) SWIG_fail;
35650 swig_obj[0] = args;
35651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35652 if (!SWIG_IsOK(res1)) {
35653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetPluginsDir" "', expected argument " "1"" of type '" "wxStandardPaths const *""'");
35654 }
35655 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35656 {
35657 PyThreadState* __tstate = wxPyBeginAllowThreads();
35658 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
35659 wxPyEndAllowThreads(__tstate);
35660 if (PyErr_Occurred()) SWIG_fail;
35661 }
35662 {
35663 #if wxUSE_UNICODE
35664 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35665 #else
35666 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35667 #endif
35668 }
35669 return resultobj;
35670 fail:
35671 return NULL;
35672 }
35673
35674
35675 SWIGINTERN PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35676 PyObject *resultobj = 0;
35677 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35678 wxString *arg2 = 0 ;
35679 void *argp1 = 0 ;
35680 int res1 = 0 ;
35681 bool temp2 = false ;
35682 PyObject * obj0 = 0 ;
35683 PyObject * obj1 = 0 ;
35684 char * kwnames[] = {
35685 (char *) "self",(char *) "prefix", NULL
35686 };
35687
35688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) SWIG_fail;
35689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35690 if (!SWIG_IsOK(res1)) {
35691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_SetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35692 }
35693 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35694 {
35695 arg2 = wxString_in_helper(obj1);
35696 if (arg2 == NULL) SWIG_fail;
35697 temp2 = true;
35698 }
35699 {
35700 PyThreadState* __tstate = wxPyBeginAllowThreads();
35701 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
35702 wxPyEndAllowThreads(__tstate);
35703 if (PyErr_Occurred()) SWIG_fail;
35704 }
35705 resultobj = SWIG_Py_Void();
35706 {
35707 if (temp2)
35708 delete arg2;
35709 }
35710 return resultobj;
35711 fail:
35712 {
35713 if (temp2)
35714 delete arg2;
35715 }
35716 return NULL;
35717 }
35718
35719
35720 SWIGINTERN PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35721 PyObject *resultobj = 0;
35722 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
35723 wxString result;
35724 void *argp1 = 0 ;
35725 int res1 = 0 ;
35726 PyObject *swig_obj[1] ;
35727
35728 if (!args) SWIG_fail;
35729 swig_obj[0] = args;
35730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStandardPaths, 0 | 0 );
35731 if (!SWIG_IsOK(res1)) {
35732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StandardPaths_GetInstallPrefix" "', expected argument " "1"" of type '" "wxStandardPaths *""'");
35733 }
35734 arg1 = reinterpret_cast< wxStandardPaths * >(argp1);
35735 {
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 result = wxStandardPaths_GetInstallPrefix(arg1);
35738 wxPyEndAllowThreads(__tstate);
35739 if (PyErr_Occurred()) SWIG_fail;
35740 }
35741 {
35742 #if wxUSE_UNICODE
35743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35744 #else
35745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35746 #endif
35747 }
35748 return resultobj;
35749 fail:
35750 return NULL;
35751 }
35752
35753
35754 SWIGINTERN PyObject *StandardPaths_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35755 PyObject *obj;
35756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
35757 SWIG_TypeNewClientData(SWIGTYPE_p_wxStandardPaths, SWIG_NewClientData(obj));
35758 return SWIG_Py_Void();
35759 }
35760
35761 static PyMethodDef SwigMethods[] = {
35762 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
35763 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
35764 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
35765 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
35766 { (char *)"SystemSettings_GetScreenType", (PyCFunction)_wrap_SystemSettings_GetScreenType, METH_NOARGS, NULL},
35767 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
35768 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
35769 { (char *)"new_SystemOptions", (PyCFunction)_wrap_new_SystemOptions, METH_NOARGS, NULL},
35770 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35771 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35772 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
35773 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
35774 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
35775 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
35776 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
35777 { (char *)"SystemOptions_swiginit", SystemOptions_swiginit, METH_VARARGS, NULL},
35778 { (char *)"NewId", (PyCFunction)_wrap_NewId, METH_NOARGS, NULL},
35779 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
35780 { (char *)"GetCurrentId", (PyCFunction)_wrap_GetCurrentId, METH_NOARGS, NULL},
35781 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
35782 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35783 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
35784 { (char *)"Bell", (PyCFunction)_wrap_Bell, METH_NOARGS, NULL},
35785 { (char *)"EndBusyCursor", (PyCFunction)_wrap_EndBusyCursor, METH_NOARGS, NULL},
35786 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
35787 { (char *)"IsBusy", (PyCFunction)_wrap_IsBusy, METH_NOARGS, NULL},
35788 { (char *)"Now", (PyCFunction)_wrap_Now, METH_NOARGS, NULL},
35789 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
35790 { (char *)"StartTimer", (PyCFunction)_wrap_StartTimer, METH_NOARGS, NULL},
35791 { (char *)"GetOsVersion", (PyCFunction)_wrap_GetOsVersion, METH_NOARGS, NULL},
35792 { (char *)"GetOsDescription", (PyCFunction)_wrap_GetOsDescription, METH_NOARGS, NULL},
35793 { (char *)"GetFreeMemory", (PyCFunction)_wrap_GetFreeMemory, METH_NOARGS, NULL},
35794 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
35795 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
35796 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35797 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
35798 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
35799 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
35800 { (char *)"GetEmailAddress", (PyCFunction)_wrap_GetEmailAddress, METH_NOARGS, NULL},
35801 { (char *)"GetHostName", (PyCFunction)_wrap_GetHostName, METH_NOARGS, NULL},
35802 { (char *)"GetFullHostName", (PyCFunction)_wrap_GetFullHostName, METH_NOARGS, NULL},
35803 { (char *)"GetUserId", (PyCFunction)_wrap_GetUserId, METH_NOARGS, NULL},
35804 { (char *)"GetUserName", (PyCFunction)_wrap_GetUserName, METH_NOARGS, NULL},
35805 { (char *)"GetHomeDir", (PyCFunction)_wrap_GetHomeDir, METH_NOARGS, NULL},
35806 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
35807 { (char *)"GetProcessId", (PyCFunction)_wrap_GetProcessId, METH_NOARGS, NULL},
35808 { (char *)"Trap", (PyCFunction)_wrap_Trap, METH_NOARGS, NULL},
35809 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35810 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35811 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35812 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
35813 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35814 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
35815 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
35816 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
35817 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
35818 { (char *)"ColourDisplay", (PyCFunction)_wrap_ColourDisplay, METH_NOARGS, NULL},
35819 { (char *)"DisplayDepth", (PyCFunction)_wrap_DisplayDepth, METH_NOARGS, NULL},
35820 { (char *)"GetDisplayDepth", (PyCFunction)_wrap_GetDisplayDepth, METH_NOARGS, NULL},
35821 { (char *)"DisplaySize", (PyCFunction)_wrap_DisplaySize, METH_NOARGS, NULL},
35822 { (char *)"GetDisplaySize", (PyCFunction)_wrap_GetDisplaySize, METH_NOARGS, NULL},
35823 { (char *)"DisplaySizeMM", (PyCFunction)_wrap_DisplaySizeMM, METH_NOARGS, NULL},
35824 { (char *)"GetDisplaySizeMM", (PyCFunction)_wrap_GetDisplaySizeMM, METH_NOARGS, NULL},
35825 { (char *)"ClientDisplayRect", (PyCFunction)_wrap_ClientDisplayRect, METH_NOARGS, NULL},
35826 { (char *)"GetClientDisplayRect", (PyCFunction)_wrap_GetClientDisplayRect, METH_NOARGS, NULL},
35827 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35828 { (char *)"GetXDisplay", (PyCFunction)_wrap_GetXDisplay, METH_NOARGS, NULL},
35829 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35830 { (char *)"GetMousePosition", (PyCFunction)_wrap_GetMousePosition, METH_NOARGS, NULL},
35831 { (char *)"FindWindowAtPointer", (PyCFunction)_wrap_FindWindowAtPointer, METH_NOARGS, NULL},
35832 { (char *)"GetActiveWindow", (PyCFunction)_wrap_GetActiveWindow, METH_NOARGS, NULL},
35833 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35834 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
35835 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
35836 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
35837 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
35838 { (char *)"new_MouseState", (PyCFunction)_wrap_new_MouseState, METH_NOARGS, NULL},
35839 { (char *)"delete_MouseState", (PyCFunction)_wrap_delete_MouseState, METH_O, NULL},
35840 { (char *)"MouseState_GetX", (PyCFunction)_wrap_MouseState_GetX, METH_O, NULL},
35841 { (char *)"MouseState_GetY", (PyCFunction)_wrap_MouseState_GetY, METH_O, NULL},
35842 { (char *)"MouseState_LeftDown", (PyCFunction)_wrap_MouseState_LeftDown, METH_O, NULL},
35843 { (char *)"MouseState_MiddleDown", (PyCFunction)_wrap_MouseState_MiddleDown, METH_O, NULL},
35844 { (char *)"MouseState_RightDown", (PyCFunction)_wrap_MouseState_RightDown, METH_O, NULL},
35845 { (char *)"MouseState_ControlDown", (PyCFunction)_wrap_MouseState_ControlDown, METH_O, NULL},
35846 { (char *)"MouseState_ShiftDown", (PyCFunction)_wrap_MouseState_ShiftDown, METH_O, NULL},
35847 { (char *)"MouseState_AltDown", (PyCFunction)_wrap_MouseState_AltDown, METH_O, NULL},
35848 { (char *)"MouseState_MetaDown", (PyCFunction)_wrap_MouseState_MetaDown, METH_O, NULL},
35849 { (char *)"MouseState_CmdDown", (PyCFunction)_wrap_MouseState_CmdDown, METH_O, NULL},
35850 { (char *)"MouseState_SetX", (PyCFunction) _wrap_MouseState_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
35851 { (char *)"MouseState_SetY", (PyCFunction) _wrap_MouseState_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
35852 { (char *)"MouseState_SetLeftDown", (PyCFunction) _wrap_MouseState_SetLeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
35853 { (char *)"MouseState_SetMiddleDown", (PyCFunction) _wrap_MouseState_SetMiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
35854 { (char *)"MouseState_SetRightDown", (PyCFunction) _wrap_MouseState_SetRightDown, METH_VARARGS | METH_KEYWORDS, NULL},
35855 { (char *)"MouseState_SetControlDown", (PyCFunction) _wrap_MouseState_SetControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
35856 { (char *)"MouseState_SetShiftDown", (PyCFunction) _wrap_MouseState_SetShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
35857 { (char *)"MouseState_SetAltDown", (PyCFunction) _wrap_MouseState_SetAltDown, METH_VARARGS | METH_KEYWORDS, NULL},
35858 { (char *)"MouseState_SetMetaDown", (PyCFunction) _wrap_MouseState_SetMetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
35859 { (char *)"MouseState_swigregister", MouseState_swigregister, METH_VARARGS, NULL},
35860 { (char *)"MouseState_swiginit", MouseState_swiginit, METH_VARARGS, NULL},
35861 { (char *)"GetMouseState", (PyCFunction)_wrap_GetMouseState, METH_NOARGS, NULL},
35862 { (char *)"WakeUpMainThread", (PyCFunction)_wrap_WakeUpMainThread, METH_NOARGS, NULL},
35863 { (char *)"MutexGuiEnter", (PyCFunction)_wrap_MutexGuiEnter, METH_NOARGS, NULL},
35864 { (char *)"MutexGuiLeave", (PyCFunction)_wrap_MutexGuiLeave, METH_NOARGS, NULL},
35865 { (char *)"new_MutexGuiLocker", (PyCFunction)_wrap_new_MutexGuiLocker, METH_NOARGS, NULL},
35866 { (char *)"delete_MutexGuiLocker", (PyCFunction)_wrap_delete_MutexGuiLocker, METH_O, NULL},
35867 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
35868 { (char *)"MutexGuiLocker_swiginit", MutexGuiLocker_swiginit, METH_VARARGS, NULL},
35869 { (char *)"Thread_IsMain", (PyCFunction)_wrap_Thread_IsMain, METH_NOARGS, NULL},
35870 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
35871 { (char *)"delete_ToolTip", (PyCFunction)_wrap_delete_ToolTip, METH_O, NULL},
35872 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
35873 { (char *)"ToolTip_GetTip", (PyCFunction)_wrap_ToolTip_GetTip, METH_O, NULL},
35874 { (char *)"ToolTip_GetWindow", (PyCFunction)_wrap_ToolTip_GetWindow, METH_O, NULL},
35875 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
35876 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
35877 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
35878 { (char *)"ToolTip_swiginit", ToolTip_swiginit, METH_VARARGS, NULL},
35879 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
35880 { (char *)"delete_Caret", (PyCFunction)_wrap_delete_Caret, METH_O, NULL},
35881 { (char *)"Caret_Destroy", (PyCFunction)_wrap_Caret_Destroy, METH_O, NULL},
35882 { (char *)"Caret_IsOk", (PyCFunction)_wrap_Caret_IsOk, METH_O, NULL},
35883 { (char *)"Caret_IsVisible", (PyCFunction)_wrap_Caret_IsVisible, METH_O, NULL},
35884 { (char *)"Caret_GetPosition", (PyCFunction)_wrap_Caret_GetPosition, METH_O, NULL},
35885 { (char *)"Caret_GetPositionTuple", (PyCFunction)_wrap_Caret_GetPositionTuple, METH_O, NULL},
35886 { (char *)"Caret_GetSize", (PyCFunction)_wrap_Caret_GetSize, METH_O, NULL},
35887 { (char *)"Caret_GetSizeTuple", (PyCFunction)_wrap_Caret_GetSizeTuple, METH_O, NULL},
35888 { (char *)"Caret_GetWindow", (PyCFunction)_wrap_Caret_GetWindow, METH_O, NULL},
35889 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
35890 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
35891 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
35892 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
35893 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
35894 { (char *)"Caret_Hide", (PyCFunction)_wrap_Caret_Hide, METH_O, NULL},
35895 { (char *)"Caret_GetBlinkTime", (PyCFunction)_wrap_Caret_GetBlinkTime, METH_NOARGS, NULL},
35896 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
35897 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
35898 { (char *)"Caret_swiginit", Caret_swiginit, METH_VARARGS, NULL},
35899 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
35900 { (char *)"delete_BusyCursor", (PyCFunction)_wrap_delete_BusyCursor, METH_O, NULL},
35901 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
35902 { (char *)"BusyCursor_swiginit", BusyCursor_swiginit, METH_VARARGS, NULL},
35903 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
35904 { (char *)"delete_WindowDisabler", (PyCFunction)_wrap_delete_WindowDisabler, METH_O, NULL},
35905 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
35906 { (char *)"WindowDisabler_swiginit", WindowDisabler_swiginit, METH_VARARGS, NULL},
35907 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35908 { (char *)"delete_BusyInfo", (PyCFunction)_wrap_delete_BusyInfo, METH_O, NULL},
35909 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
35910 { (char *)"BusyInfo_swiginit", BusyInfo_swiginit, METH_VARARGS, NULL},
35911 { (char *)"new_StopWatch", (PyCFunction)_wrap_new_StopWatch, METH_NOARGS, NULL},
35912 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35913 { (char *)"StopWatch_Pause", (PyCFunction)_wrap_StopWatch_Pause, METH_O, NULL},
35914 { (char *)"StopWatch_Resume", (PyCFunction)_wrap_StopWatch_Resume, METH_O, NULL},
35915 { (char *)"StopWatch_Time", (PyCFunction)_wrap_StopWatch_Time, METH_O, NULL},
35916 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
35917 { (char *)"StopWatch_swiginit", StopWatch_swiginit, METH_VARARGS, NULL},
35918 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35919 { (char *)"delete_FileHistory", (PyCFunction)_wrap_delete_FileHistory, METH_O, NULL},
35920 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35921 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
35922 { (char *)"FileHistory_GetMaxFiles", (PyCFunction)_wrap_FileHistory_GetMaxFiles, METH_O, NULL},
35923 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35924 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35925 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
35926 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
35927 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction)_wrap_FileHistory_AddFilesToMenu, METH_O, NULL},
35928 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
35929 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
35930 { (char *)"FileHistory_GetCount", (PyCFunction)_wrap_FileHistory_GetCount, METH_O, NULL},
35931 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
35932 { (char *)"FileHistory_swiginit", FileHistory_swiginit, METH_VARARGS, NULL},
35933 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
35934 { (char *)"new_PreSingleInstanceChecker", (PyCFunction)_wrap_new_PreSingleInstanceChecker, METH_NOARGS, NULL},
35935 { (char *)"delete_SingleInstanceChecker", (PyCFunction)_wrap_delete_SingleInstanceChecker, METH_O, NULL},
35936 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
35937 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction)_wrap_SingleInstanceChecker_IsAnotherRunning, METH_O, NULL},
35938 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
35939 { (char *)"SingleInstanceChecker_swiginit", SingleInstanceChecker_swiginit, METH_VARARGS, NULL},
35940 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
35941 { (char *)"delete_TipProvider", (PyCFunction)_wrap_delete_TipProvider, METH_O, NULL},
35942 { (char *)"TipProvider_GetTip", (PyCFunction)_wrap_TipProvider_GetTip, METH_O, NULL},
35943 { (char *)"TipProvider_GetCurrentTip", (PyCFunction)_wrap_TipProvider_GetCurrentTip, METH_O, NULL},
35944 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
35945 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
35946 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35947 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35948 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
35949 { (char *)"PyTipProvider_swiginit", PyTipProvider_swiginit, METH_VARARGS, NULL},
35950 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
35951 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
35952 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
35953 { (char *)"delete_Timer", (PyCFunction)_wrap_delete_Timer, METH_O, NULL},
35954 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
35955 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
35956 { (char *)"Timer_GetOwner", (PyCFunction)_wrap_Timer_GetOwner, METH_O, NULL},
35957 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35958 { (char *)"Timer_Stop", (PyCFunction)_wrap_Timer_Stop, METH_O, NULL},
35959 { (char *)"Timer_Notify", (PyCFunction)_wrap_Timer_Notify, METH_O, NULL},
35960 { (char *)"Timer_IsRunning", (PyCFunction)_wrap_Timer_IsRunning, METH_O, NULL},
35961 { (char *)"Timer_GetInterval", (PyCFunction)_wrap_Timer_GetInterval, METH_O, NULL},
35962 { (char *)"Timer_GetId", (PyCFunction)_wrap_Timer_GetId, METH_O, NULL},
35963 { (char *)"Timer_IsOneShot", (PyCFunction)_wrap_Timer_IsOneShot, METH_O, NULL},
35964 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
35965 { (char *)"Timer_swiginit", Timer_swiginit, METH_VARARGS, NULL},
35966 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
35967 { (char *)"TimerEvent_GetInterval", (PyCFunction)_wrap_TimerEvent_GetInterval, METH_O, NULL},
35968 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
35969 { (char *)"TimerEvent_swiginit", TimerEvent_swiginit, METH_VARARGS, NULL},
35970 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
35971 { (char *)"delete_TimerRunner", (PyCFunction)_wrap_delete_TimerRunner, METH_O, NULL},
35972 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
35973 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
35974 { (char *)"TimerRunner_swiginit", TimerRunner_swiginit, METH_VARARGS, NULL},
35975 { (char *)"new_Log", (PyCFunction)_wrap_new_Log, METH_NOARGS, NULL},
35976 { (char *)"delete_Log", (PyCFunction)_wrap_delete_Log, METH_O, NULL},
35977 { (char *)"Log_IsEnabled", (PyCFunction)_wrap_Log_IsEnabled, METH_NOARGS, NULL},
35978 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
35979 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
35980 { (char *)"Log_Flush", (PyCFunction)_wrap_Log_Flush, METH_O, NULL},
35981 { (char *)"Log_FlushActive", (PyCFunction)_wrap_Log_FlushActive, METH_NOARGS, NULL},
35982 { (char *)"Log_GetActiveTarget", (PyCFunction)_wrap_Log_GetActiveTarget, METH_NOARGS, NULL},
35983 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
35984 { (char *)"Log_Suspend", (PyCFunction)_wrap_Log_Suspend, METH_NOARGS, NULL},
35985 { (char *)"Log_Resume", (PyCFunction)_wrap_Log_Resume, METH_NOARGS, NULL},
35986 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
35987 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
35988 { (char *)"Log_DontCreateOnDemand", (PyCFunction)_wrap_Log_DontCreateOnDemand, METH_NOARGS, NULL},
35989 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35990 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35991 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35992 { (char *)"Log_ClearTraceMasks", (PyCFunction)_wrap_Log_ClearTraceMasks, METH_NOARGS, NULL},
35993 { (char *)"Log_GetTraceMasks", (PyCFunction)_wrap_Log_GetTraceMasks, METH_NOARGS, NULL},
35994 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
35995 { (char *)"Log_GetVerbose", (PyCFunction)_wrap_Log_GetVerbose, METH_NOARGS, NULL},
35996 { (char *)"Log_GetTraceMask", (PyCFunction)_wrap_Log_GetTraceMask, METH_NOARGS, NULL},
35997 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
35998 { (char *)"Log_GetLogLevel", (PyCFunction)_wrap_Log_GetLogLevel, METH_NOARGS, NULL},
35999 { (char *)"Log_GetTimestamp", (PyCFunction)_wrap_Log_GetTimestamp, METH_NOARGS, NULL},
36000 { (char *)"Log_TimeStamp", (PyCFunction)_wrap_Log_TimeStamp, METH_NOARGS, NULL},
36001 { (char *)"Log_Destroy", (PyCFunction)_wrap_Log_Destroy, METH_O, NULL},
36002 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
36003 { (char *)"Log_swiginit", Log_swiginit, METH_VARARGS, NULL},
36004 { (char *)"new_LogStderr", (PyCFunction)_wrap_new_LogStderr, METH_NOARGS, NULL},
36005 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
36006 { (char *)"LogStderr_swiginit", LogStderr_swiginit, METH_VARARGS, NULL},
36007 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
36008 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
36009 { (char *)"LogTextCtrl_swiginit", LogTextCtrl_swiginit, METH_VARARGS, NULL},
36010 { (char *)"new_LogGui", (PyCFunction)_wrap_new_LogGui, METH_NOARGS, NULL},
36011 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
36012 { (char *)"LogGui_swiginit", LogGui_swiginit, METH_VARARGS, NULL},
36013 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36014 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
36015 { (char *)"LogWindow_GetFrame", (PyCFunction)_wrap_LogWindow_GetFrame, METH_O, NULL},
36016 { (char *)"LogWindow_GetOldLog", (PyCFunction)_wrap_LogWindow_GetOldLog, METH_O, NULL},
36017 { (char *)"LogWindow_IsPassingMessages", (PyCFunction)_wrap_LogWindow_IsPassingMessages, METH_O, NULL},
36018 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36019 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
36020 { (char *)"LogWindow_swiginit", LogWindow_swiginit, METH_VARARGS, NULL},
36021 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
36022 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
36023 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
36024 { (char *)"LogChain_IsPassingMessages", (PyCFunction)_wrap_LogChain_IsPassingMessages, METH_O, NULL},
36025 { (char *)"LogChain_GetOldLog", (PyCFunction)_wrap_LogChain_GetOldLog, METH_O, NULL},
36026 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
36027 { (char *)"LogChain_swiginit", LogChain_swiginit, METH_VARARGS, NULL},
36028 { (char *)"new_LogBuffer", (PyCFunction)_wrap_new_LogBuffer, METH_NOARGS, NULL},
36029 { (char *)"LogBuffer_GetBuffer", (PyCFunction)_wrap_LogBuffer_GetBuffer, METH_O, NULL},
36030 { (char *)"LogBuffer_swigregister", LogBuffer_swigregister, METH_VARARGS, NULL},
36031 { (char *)"LogBuffer_swiginit", LogBuffer_swiginit, METH_VARARGS, NULL},
36032 { (char *)"SysErrorCode", (PyCFunction)_wrap_SysErrorCode, METH_NOARGS, NULL},
36033 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
36034 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
36035 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
36036 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
36037 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36038 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36039 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
36040 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
36041 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
36042 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
36043 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
36044 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
36045 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
36046 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
36047 { (char *)"new_LogNull", (PyCFunction)_wrap_new_LogNull, METH_NOARGS, NULL},
36048 { (char *)"delete_LogNull", (PyCFunction)_wrap_delete_LogNull, METH_O, NULL},
36049 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
36050 { (char *)"LogNull_swiginit", LogNull_swiginit, METH_VARARGS, NULL},
36051 { (char *)"new_PyLog", (PyCFunction)_wrap_new_PyLog, METH_NOARGS, NULL},
36052 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36053 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
36054 { (char *)"PyLog_swiginit", PyLog_swiginit, METH_VARARGS, NULL},
36055 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36056 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36057 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
36058 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
36059 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36060 { (char *)"Process_OnTerminate", (PyCFunction) _wrap_Process_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
36061 { (char *)"Process_Redirect", (PyCFunction)_wrap_Process_Redirect, METH_O, NULL},
36062 { (char *)"Process_IsRedirected", (PyCFunction)_wrap_Process_IsRedirected, METH_O, NULL},
36063 { (char *)"Process_Detach", (PyCFunction)_wrap_Process_Detach, METH_O, NULL},
36064 { (char *)"Process_GetInputStream", (PyCFunction)_wrap_Process_GetInputStream, METH_O, NULL},
36065 { (char *)"Process_GetErrorStream", (PyCFunction)_wrap_Process_GetErrorStream, METH_O, NULL},
36066 { (char *)"Process_GetOutputStream", (PyCFunction)_wrap_Process_GetOutputStream, METH_O, NULL},
36067 { (char *)"Process_CloseOutput", (PyCFunction)_wrap_Process_CloseOutput, METH_O, NULL},
36068 { (char *)"Process_IsInputOpened", (PyCFunction)_wrap_Process_IsInputOpened, METH_O, NULL},
36069 { (char *)"Process_IsInputAvailable", (PyCFunction)_wrap_Process_IsInputAvailable, METH_O, NULL},
36070 { (char *)"Process_IsErrorAvailable", (PyCFunction)_wrap_Process_IsErrorAvailable, METH_O, NULL},
36071 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
36072 { (char *)"Process_swiginit", Process_swiginit, METH_VARARGS, NULL},
36073 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36074 { (char *)"ProcessEvent_GetPid", (PyCFunction)_wrap_ProcessEvent_GetPid, METH_O, NULL},
36075 { (char *)"ProcessEvent_GetExitCode", (PyCFunction)_wrap_ProcessEvent_GetExitCode, METH_O, NULL},
36076 { (char *)"ProcessEvent_m_pid_set", _wrap_ProcessEvent_m_pid_set, METH_VARARGS, NULL},
36077 { (char *)"ProcessEvent_m_pid_get", (PyCFunction)_wrap_ProcessEvent_m_pid_get, METH_O, NULL},
36078 { (char *)"ProcessEvent_m_exitcode_set", _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS, NULL},
36079 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction)_wrap_ProcessEvent_m_exitcode_get, METH_O, NULL},
36080 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
36081 { (char *)"ProcessEvent_swiginit", ProcessEvent_swiginit, METH_VARARGS, NULL},
36082 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
36083 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
36084 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
36085 { (char *)"delete_Joystick", (PyCFunction)_wrap_delete_Joystick, METH_O, NULL},
36086 { (char *)"Joystick_GetPosition", (PyCFunction)_wrap_Joystick_GetPosition, METH_O, NULL},
36087 { (char *)"Joystick_GetZPosition", (PyCFunction)_wrap_Joystick_GetZPosition, METH_O, NULL},
36088 { (char *)"Joystick_GetButtonState", (PyCFunction)_wrap_Joystick_GetButtonState, METH_O, NULL},
36089 { (char *)"Joystick_GetPOVPosition", (PyCFunction)_wrap_Joystick_GetPOVPosition, METH_O, NULL},
36090 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction)_wrap_Joystick_GetPOVCTSPosition, METH_O, NULL},
36091 { (char *)"Joystick_GetRudderPosition", (PyCFunction)_wrap_Joystick_GetRudderPosition, METH_O, NULL},
36092 { (char *)"Joystick_GetUPosition", (PyCFunction)_wrap_Joystick_GetUPosition, METH_O, NULL},
36093 { (char *)"Joystick_GetVPosition", (PyCFunction)_wrap_Joystick_GetVPosition, METH_O, NULL},
36094 { (char *)"Joystick_GetMovementThreshold", (PyCFunction)_wrap_Joystick_GetMovementThreshold, METH_O, NULL},
36095 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
36096 { (char *)"Joystick_IsOk", (PyCFunction)_wrap_Joystick_IsOk, METH_O, NULL},
36097 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction)_wrap_Joystick_GetNumberJoysticks, METH_O, NULL},
36098 { (char *)"Joystick_GetManufacturerId", (PyCFunction)_wrap_Joystick_GetManufacturerId, METH_O, NULL},
36099 { (char *)"Joystick_GetProductId", (PyCFunction)_wrap_Joystick_GetProductId, METH_O, NULL},
36100 { (char *)"Joystick_GetProductName", (PyCFunction)_wrap_Joystick_GetProductName, METH_O, NULL},
36101 { (char *)"Joystick_GetXMin", (PyCFunction)_wrap_Joystick_GetXMin, METH_O, NULL},
36102 { (char *)"Joystick_GetYMin", (PyCFunction)_wrap_Joystick_GetYMin, METH_O, NULL},
36103 { (char *)"Joystick_GetZMin", (PyCFunction)_wrap_Joystick_GetZMin, METH_O, NULL},
36104 { (char *)"Joystick_GetXMax", (PyCFunction)_wrap_Joystick_GetXMax, METH_O, NULL},
36105 { (char *)"Joystick_GetYMax", (PyCFunction)_wrap_Joystick_GetYMax, METH_O, NULL},
36106 { (char *)"Joystick_GetZMax", (PyCFunction)_wrap_Joystick_GetZMax, METH_O, NULL},
36107 { (char *)"Joystick_GetNumberButtons", (PyCFunction)_wrap_Joystick_GetNumberButtons, METH_O, NULL},
36108 { (char *)"Joystick_GetNumberAxes", (PyCFunction)_wrap_Joystick_GetNumberAxes, METH_O, NULL},
36109 { (char *)"Joystick_GetMaxButtons", (PyCFunction)_wrap_Joystick_GetMaxButtons, METH_O, NULL},
36110 { (char *)"Joystick_GetMaxAxes", (PyCFunction)_wrap_Joystick_GetMaxAxes, METH_O, NULL},
36111 { (char *)"Joystick_GetPollingMin", (PyCFunction)_wrap_Joystick_GetPollingMin, METH_O, NULL},
36112 { (char *)"Joystick_GetPollingMax", (PyCFunction)_wrap_Joystick_GetPollingMax, METH_O, NULL},
36113 { (char *)"Joystick_GetRudderMin", (PyCFunction)_wrap_Joystick_GetRudderMin, METH_O, NULL},
36114 { (char *)"Joystick_GetRudderMax", (PyCFunction)_wrap_Joystick_GetRudderMax, METH_O, NULL},
36115 { (char *)"Joystick_GetUMin", (PyCFunction)_wrap_Joystick_GetUMin, METH_O, NULL},
36116 { (char *)"Joystick_GetUMax", (PyCFunction)_wrap_Joystick_GetUMax, METH_O, NULL},
36117 { (char *)"Joystick_GetVMin", (PyCFunction)_wrap_Joystick_GetVMin, METH_O, NULL},
36118 { (char *)"Joystick_GetVMax", (PyCFunction)_wrap_Joystick_GetVMax, METH_O, NULL},
36119 { (char *)"Joystick_HasRudder", (PyCFunction)_wrap_Joystick_HasRudder, METH_O, NULL},
36120 { (char *)"Joystick_HasZ", (PyCFunction)_wrap_Joystick_HasZ, METH_O, NULL},
36121 { (char *)"Joystick_HasU", (PyCFunction)_wrap_Joystick_HasU, METH_O, NULL},
36122 { (char *)"Joystick_HasV", (PyCFunction)_wrap_Joystick_HasV, METH_O, NULL},
36123 { (char *)"Joystick_HasPOV", (PyCFunction)_wrap_Joystick_HasPOV, METH_O, NULL},
36124 { (char *)"Joystick_HasPOV4Dir", (PyCFunction)_wrap_Joystick_HasPOV4Dir, METH_O, NULL},
36125 { (char *)"Joystick_HasPOVCTS", (PyCFunction)_wrap_Joystick_HasPOVCTS, METH_O, NULL},
36126 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
36127 { (char *)"Joystick_ReleaseCapture", (PyCFunction)_wrap_Joystick_ReleaseCapture, METH_O, NULL},
36128 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
36129 { (char *)"Joystick_swiginit", Joystick_swiginit, METH_VARARGS, NULL},
36130 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
36131 { (char *)"JoystickEvent_GetPosition", (PyCFunction)_wrap_JoystickEvent_GetPosition, METH_O, NULL},
36132 { (char *)"JoystickEvent_GetZPosition", (PyCFunction)_wrap_JoystickEvent_GetZPosition, METH_O, NULL},
36133 { (char *)"JoystickEvent_GetButtonState", (PyCFunction)_wrap_JoystickEvent_GetButtonState, METH_O, NULL},
36134 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction)_wrap_JoystickEvent_GetButtonChange, METH_O, NULL},
36135 { (char *)"JoystickEvent_GetJoystick", (PyCFunction)_wrap_JoystickEvent_GetJoystick, METH_O, NULL},
36136 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
36137 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
36138 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
36139 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36140 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
36141 { (char *)"JoystickEvent_IsButton", (PyCFunction)_wrap_JoystickEvent_IsButton, METH_O, NULL},
36142 { (char *)"JoystickEvent_IsMove", (PyCFunction)_wrap_JoystickEvent_IsMove, METH_O, NULL},
36143 { (char *)"JoystickEvent_IsZMove", (PyCFunction)_wrap_JoystickEvent_IsZMove, METH_O, NULL},
36144 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
36145 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
36146 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
36147 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
36148 { (char *)"JoystickEvent_swiginit", JoystickEvent_swiginit, METH_VARARGS, NULL},
36149 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
36150 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36151 { (char *)"delete_Sound", (PyCFunction)_wrap_delete_Sound, METH_O, NULL},
36152 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
36153 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
36154 { (char *)"Sound_IsOk", (PyCFunction)_wrap_Sound_IsOk, METH_O, NULL},
36155 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
36156 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
36157 { (char *)"Sound_Stop", (PyCFunction)_wrap_Sound_Stop, METH_NOARGS, NULL},
36158 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
36159 { (char *)"Sound_swiginit", Sound_swiginit, METH_VARARGS, NULL},
36160 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36161 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
36162 { (char *)"new_NullFileTypeInfo", (PyCFunction)_wrap_new_NullFileTypeInfo, METH_NOARGS, NULL},
36163 { (char *)"FileTypeInfo_IsValid", (PyCFunction)_wrap_FileTypeInfo_IsValid, METH_O, NULL},
36164 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36165 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
36166 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction)_wrap_FileTypeInfo_GetMimeType, METH_O, NULL},
36167 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction)_wrap_FileTypeInfo_GetOpenCommand, METH_O, NULL},
36168 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction)_wrap_FileTypeInfo_GetPrintCommand, METH_O, NULL},
36169 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction)_wrap_FileTypeInfo_GetShortDesc, METH_O, NULL},
36170 { (char *)"FileTypeInfo_GetDescription", (PyCFunction)_wrap_FileTypeInfo_GetDescription, METH_O, NULL},
36171 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction)_wrap_FileTypeInfo_GetExtensions, METH_O, NULL},
36172 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction)_wrap_FileTypeInfo_GetExtensionsCount, METH_O, NULL},
36173 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction)_wrap_FileTypeInfo_GetIconFile, METH_O, NULL},
36174 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction)_wrap_FileTypeInfo_GetIconIndex, METH_O, NULL},
36175 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
36176 { (char *)"FileTypeInfo_swiginit", FileTypeInfo_swiginit, METH_VARARGS, NULL},
36177 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
36178 { (char *)"delete_FileType", (PyCFunction)_wrap_delete_FileType, METH_O, NULL},
36179 { (char *)"FileType_GetMimeType", (PyCFunction)_wrap_FileType_GetMimeType, METH_O, NULL},
36180 { (char *)"FileType_GetMimeTypes", (PyCFunction)_wrap_FileType_GetMimeTypes, METH_O, NULL},
36181 { (char *)"FileType_GetExtensions", (PyCFunction)_wrap_FileType_GetExtensions, METH_O, NULL},
36182 { (char *)"FileType_GetIcon", (PyCFunction)_wrap_FileType_GetIcon, METH_O, NULL},
36183 { (char *)"FileType_GetIconInfo", (PyCFunction)_wrap_FileType_GetIconInfo, METH_O, NULL},
36184 { (char *)"FileType_GetDescription", (PyCFunction)_wrap_FileType_GetDescription, METH_O, NULL},
36185 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36186 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36187 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
36188 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36189 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36190 { (char *)"FileType_Unassociate", (PyCFunction)_wrap_FileType_Unassociate, METH_O, NULL},
36191 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
36192 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
36193 { (char *)"FileType_swiginit", FileType_swiginit, METH_VARARGS, NULL},
36194 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
36195 { (char *)"new_MimeTypesManager", (PyCFunction)_wrap_new_MimeTypesManager, METH_NOARGS, NULL},
36196 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
36197 { (char *)"MimeTypesManager_ClearData", (PyCFunction)_wrap_MimeTypesManager_ClearData, METH_O, NULL},
36198 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
36199 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
36200 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
36201 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
36202 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction)_wrap_MimeTypesManager_EnumAllFileTypes, METH_O, NULL},
36203 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
36204 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
36205 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
36206 { (char *)"delete_MimeTypesManager", (PyCFunction)_wrap_delete_MimeTypesManager, METH_O, NULL},
36207 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
36208 { (char *)"MimeTypesManager_swiginit", MimeTypesManager_swiginit, METH_VARARGS, NULL},
36209 { (char *)"new_ArtProvider", (PyCFunction)_wrap_new_ArtProvider, METH_NOARGS, NULL},
36210 { (char *)"delete_ArtProvider", (PyCFunction)_wrap_delete_ArtProvider, METH_O, NULL},
36211 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36212 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36213 { (char *)"ArtProvider_PopProvider", (PyCFunction)_wrap_ArtProvider_PopProvider, METH_NOARGS, NULL},
36214 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
36215 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36216 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
36217 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
36218 { (char *)"ArtProvider_Destroy", (PyCFunction)_wrap_ArtProvider_Destroy, METH_O, NULL},
36219 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
36220 { (char *)"ArtProvider_swiginit", ArtProvider_swiginit, METH_VARARGS, NULL},
36221 { (char *)"delete_ConfigBase", (PyCFunction)_wrap_delete_ConfigBase, METH_O, NULL},
36222 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36223 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
36224 { (char *)"ConfigBase_Create", (PyCFunction)_wrap_ConfigBase_Create, METH_NOARGS, NULL},
36225 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction)_wrap_ConfigBase_DontCreateOnDemand, METH_NOARGS, NULL},
36226 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
36227 { (char *)"ConfigBase_GetPath", (PyCFunction)_wrap_ConfigBase_GetPath, METH_O, NULL},
36228 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction)_wrap_ConfigBase_GetFirstGroup, METH_O, NULL},
36229 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36230 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction)_wrap_ConfigBase_GetFirstEntry, METH_O, NULL},
36231 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36232 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
36233 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
36234 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36235 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36236 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
36237 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
36238 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
36239 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
36240 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36241 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
36242 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
36243 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
36244 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
36245 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
36246 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
36247 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36248 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36249 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
36250 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
36251 { (char *)"ConfigBase_DeleteAll", (PyCFunction)_wrap_ConfigBase_DeleteAll, METH_O, NULL},
36252 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36253 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction)_wrap_ConfigBase_IsExpandingEnvVars, METH_O, NULL},
36254 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
36255 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction)_wrap_ConfigBase_IsRecordingDefaults, METH_O, NULL},
36256 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36257 { (char *)"ConfigBase_GetAppName", (PyCFunction)_wrap_ConfigBase_GetAppName, METH_O, NULL},
36258 { (char *)"ConfigBase_GetVendorName", (PyCFunction)_wrap_ConfigBase_GetVendorName, METH_O, NULL},
36259 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
36260 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
36261 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
36262 { (char *)"ConfigBase_GetStyle", (PyCFunction)_wrap_ConfigBase_GetStyle, METH_O, NULL},
36263 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
36264 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
36265 { (char *)"delete_Config", (PyCFunction)_wrap_delete_Config, METH_O, NULL},
36266 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
36267 { (char *)"Config_swiginit", Config_swiginit, METH_VARARGS, NULL},
36268 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
36269 { (char *)"delete_FileConfig", (PyCFunction)_wrap_delete_FileConfig, METH_O, NULL},
36270 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
36271 { (char *)"FileConfig_swiginit", FileConfig_swiginit, METH_VARARGS, NULL},
36272 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
36273 { (char *)"delete_ConfigPathChanger", (PyCFunction)_wrap_delete_ConfigPathChanger, METH_O, NULL},
36274 { (char *)"ConfigPathChanger_Name", (PyCFunction)_wrap_ConfigPathChanger_Name, METH_O, NULL},
36275 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
36276 { (char *)"ConfigPathChanger_swiginit", ConfigPathChanger_swiginit, METH_VARARGS, NULL},
36277 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
36278 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36279 { (char *)"DateTime_GetCountry", (PyCFunction)_wrap_DateTime_GetCountry, METH_NOARGS, NULL},
36280 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
36281 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
36282 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
36283 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36284 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
36285 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
36286 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
36287 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36288 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
36289 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
36290 { (char *)"DateTime_GetAmPmStrings", (PyCFunction)_wrap_DateTime_GetAmPmStrings, METH_NOARGS, NULL},
36291 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
36292 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
36293 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
36294 { (char *)"DateTime_Now", (PyCFunction)_wrap_DateTime_Now, METH_NOARGS, NULL},
36295 { (char *)"DateTime_UNow", (PyCFunction)_wrap_DateTime_UNow, METH_NOARGS, NULL},
36296 { (char *)"DateTime_Today", (PyCFunction)_wrap_DateTime_Today, METH_NOARGS, NULL},
36297 { (char *)"new_DateTime", (PyCFunction)_wrap_new_DateTime, METH_NOARGS, NULL},
36298 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36299 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36300 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36301 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
36302 { (char *)"new_DateTimeFromDateTime", (PyCFunction) _wrap_new_DateTimeFromDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36303 { (char *)"delete_DateTime", (PyCFunction)_wrap_delete_DateTime, METH_O, NULL},
36304 { (char *)"DateTime_SetToCurrent", (PyCFunction)_wrap_DateTime_SetToCurrent, METH_O, NULL},
36305 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
36306 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
36307 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
36308 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
36309 { (char *)"DateTime_ResetTime", (PyCFunction)_wrap_DateTime_ResetTime, METH_O, NULL},
36310 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36311 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36312 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36313 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36314 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36315 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36316 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36317 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36318 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36319 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36320 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36321 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36322 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36323 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36324 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36325 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36326 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36327 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
36328 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36329 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36330 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
36331 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36332 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
36333 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction)_wrap_DateTime_GetJulianDayNumber, METH_O, NULL},
36334 { (char *)"DateTime_GetJDN", (PyCFunction)_wrap_DateTime_GetJDN, METH_O, NULL},
36335 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction)_wrap_DateTime_GetModifiedJulianDayNumber, METH_O, NULL},
36336 { (char *)"DateTime_GetMJD", (PyCFunction)_wrap_DateTime_GetMJD, METH_O, NULL},
36337 { (char *)"DateTime_GetRataDie", (PyCFunction)_wrap_DateTime_GetRataDie, METH_O, NULL},
36338 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36339 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36340 { (char *)"DateTime_FromTimezone", (PyCFunction) _wrap_DateTime_FromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36341 { (char *)"DateTime_MakeFromTimezone", (PyCFunction) _wrap_DateTime_MakeFromTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
36342 { (char *)"DateTime_ToUTC", (PyCFunction) _wrap_DateTime_ToUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36343 { (char *)"DateTime_MakeUTC", (PyCFunction) _wrap_DateTime_MakeUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36344 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36345 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
36346 { (char *)"DateTime_FromUTC", (PyCFunction) _wrap_DateTime_FromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36347 { (char *)"DateTime_MakeFromUTC", (PyCFunction) _wrap_DateTime_MakeFromUTC, METH_VARARGS | METH_KEYWORDS, NULL},
36348 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
36349 { (char *)"DateTime_IsValid", (PyCFunction)_wrap_DateTime_IsValid, METH_O, NULL},
36350 { (char *)"DateTime_GetTicks", (PyCFunction)_wrap_DateTime_GetTicks, METH_O, NULL},
36351 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
36352 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36353 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
36354 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
36355 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
36356 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
36357 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
36358 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
36359 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36360 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
36361 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
36362 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
36363 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36364 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
36365 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36366 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36367 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
36368 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
36369 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
36370 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
36371 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
36372 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
36373 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
36374 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
36375 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36376 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
36377 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
36378 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
36379 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
36380 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36381 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36382 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36383 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36384 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36385 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36386 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
36387 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36388 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
36389 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
36390 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
36391 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36392 { (char *)"DateTime_FormatDate", (PyCFunction)_wrap_DateTime_FormatDate, METH_O, NULL},
36393 { (char *)"DateTime_FormatTime", (PyCFunction)_wrap_DateTime_FormatTime, METH_O, NULL},
36394 { (char *)"DateTime_FormatISODate", (PyCFunction)_wrap_DateTime_FormatISODate, METH_O, NULL},
36395 { (char *)"DateTime_FormatISOTime", (PyCFunction)_wrap_DateTime_FormatISOTime, METH_O, NULL},
36396 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
36397 { (char *)"DateTime_swiginit", DateTime_swiginit, METH_VARARGS, NULL},
36398 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
36399 { (char *)"TimeSpan_Second", (PyCFunction)_wrap_TimeSpan_Second, METH_NOARGS, NULL},
36400 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
36401 { (char *)"TimeSpan_Minute", (PyCFunction)_wrap_TimeSpan_Minute, METH_NOARGS, NULL},
36402 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
36403 { (char *)"TimeSpan_Hour", (PyCFunction)_wrap_TimeSpan_Hour, METH_NOARGS, NULL},
36404 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36405 { (char *)"TimeSpan_Day", (PyCFunction)_wrap_TimeSpan_Day, METH_NOARGS, NULL},
36406 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36407 { (char *)"TimeSpan_Week", (PyCFunction)_wrap_TimeSpan_Week, METH_NOARGS, NULL},
36408 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36409 { (char *)"delete_TimeSpan", (PyCFunction)_wrap_delete_TimeSpan, METH_O, NULL},
36410 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36411 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36412 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36413 { (char *)"TimeSpan_Neg", (PyCFunction)_wrap_TimeSpan_Neg, METH_O, NULL},
36414 { (char *)"TimeSpan_Abs", (PyCFunction)_wrap_TimeSpan_Abs, METH_O, NULL},
36415 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36416 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36417 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36418 { (char *)"TimeSpan___neg__", (PyCFunction)_wrap_TimeSpan___neg__, METH_O, NULL},
36419 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36420 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36421 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36422 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36423 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
36424 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
36425 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
36426 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
36427 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36428 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36429 { (char *)"TimeSpan_IsNull", (PyCFunction)_wrap_TimeSpan_IsNull, METH_O, NULL},
36430 { (char *)"TimeSpan_IsPositive", (PyCFunction)_wrap_TimeSpan_IsPositive, METH_O, NULL},
36431 { (char *)"TimeSpan_IsNegative", (PyCFunction)_wrap_TimeSpan_IsNegative, METH_O, NULL},
36432 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
36433 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
36434 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
36435 { (char *)"TimeSpan_GetWeeks", (PyCFunction)_wrap_TimeSpan_GetWeeks, METH_O, NULL},
36436 { (char *)"TimeSpan_GetDays", (PyCFunction)_wrap_TimeSpan_GetDays, METH_O, NULL},
36437 { (char *)"TimeSpan_GetHours", (PyCFunction)_wrap_TimeSpan_GetHours, METH_O, NULL},
36438 { (char *)"TimeSpan_GetMinutes", (PyCFunction)_wrap_TimeSpan_GetMinutes, METH_O, NULL},
36439 { (char *)"TimeSpan_GetSeconds", (PyCFunction)_wrap_TimeSpan_GetSeconds, METH_O, NULL},
36440 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction)_wrap_TimeSpan_GetMilliseconds, METH_O, NULL},
36441 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
36442 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
36443 { (char *)"TimeSpan_swiginit", TimeSpan_swiginit, METH_VARARGS, NULL},
36444 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
36445 { (char *)"delete_DateSpan", (PyCFunction)_wrap_delete_DateSpan, METH_O, NULL},
36446 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
36447 { (char *)"DateSpan_Day", (PyCFunction)_wrap_DateSpan_Day, METH_NOARGS, NULL},
36448 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
36449 { (char *)"DateSpan_Week", (PyCFunction)_wrap_DateSpan_Week, METH_NOARGS, NULL},
36450 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
36451 { (char *)"DateSpan_Month", (PyCFunction)_wrap_DateSpan_Month, METH_NOARGS, NULL},
36452 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
36453 { (char *)"DateSpan_Year", (PyCFunction)_wrap_DateSpan_Year, METH_NOARGS, NULL},
36454 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
36455 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
36456 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
36457 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
36458 { (char *)"DateSpan_GetYears", (PyCFunction)_wrap_DateSpan_GetYears, METH_O, NULL},
36459 { (char *)"DateSpan_GetMonths", (PyCFunction)_wrap_DateSpan_GetMonths, METH_O, NULL},
36460 { (char *)"DateSpan_GetWeeks", (PyCFunction)_wrap_DateSpan_GetWeeks, METH_O, NULL},
36461 { (char *)"DateSpan_GetDays", (PyCFunction)_wrap_DateSpan_GetDays, METH_O, NULL},
36462 { (char *)"DateSpan_GetTotalDays", (PyCFunction)_wrap_DateSpan_GetTotalDays, METH_O, NULL},
36463 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36464 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
36465 { (char *)"DateSpan_Neg", (PyCFunction)_wrap_DateSpan_Neg, METH_O, NULL},
36466 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
36467 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
36468 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
36469 { (char *)"DateSpan___neg__", (PyCFunction)_wrap_DateSpan___neg__, METH_O, NULL},
36470 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
36471 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
36472 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
36473 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
36474 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
36475 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36476 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36477 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
36478 { (char *)"DateSpan_swiginit", DateSpan_swiginit, METH_VARARGS, NULL},
36479 { (char *)"GetLocalTime", (PyCFunction)_wrap_GetLocalTime, METH_NOARGS, NULL},
36480 { (char *)"GetUTCTime", (PyCFunction)_wrap_GetUTCTime, METH_NOARGS, NULL},
36481 { (char *)"GetCurrentTime", (PyCFunction)_wrap_GetCurrentTime, METH_NOARGS, NULL},
36482 { (char *)"GetLocalTimeMillis", (PyCFunction)_wrap_GetLocalTimeMillis, METH_NOARGS, NULL},
36483 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36484 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36485 { (char *)"delete_DataFormat", (PyCFunction)_wrap_delete_DataFormat, METH_O, NULL},
36486 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
36487 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
36488 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
36489 { (char *)"DataFormat_GetType", (PyCFunction)_wrap_DataFormat_GetType, METH_O, NULL},
36490 { (char *)"DataFormat_GetId", (PyCFunction)_wrap_DataFormat_GetId, METH_O, NULL},
36491 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
36492 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
36493 { (char *)"DataFormat_swiginit", DataFormat_swiginit, METH_VARARGS, NULL},
36494 { (char *)"delete_DataObject", (PyCFunction)_wrap_delete_DataObject, METH_O, NULL},
36495 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36496 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
36497 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36498 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
36499 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
36500 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
36501 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36502 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
36503 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36504 { (char *)"DataObjectSimple_GetFormat", (PyCFunction)_wrap_DataObjectSimple_GetFormat, METH_O, NULL},
36505 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
36506 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction)_wrap_DataObjectSimple_GetDataSize, METH_O, NULL},
36507 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction)_wrap_DataObjectSimple_GetDataHere, METH_O, NULL},
36508 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36509 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
36510 { (char *)"DataObjectSimple_swiginit", DataObjectSimple_swiginit, METH_VARARGS, NULL},
36511 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
36512 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36513 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
36514 { (char *)"PyDataObjectSimple_swiginit", PyDataObjectSimple_swiginit, METH_VARARGS, NULL},
36515 { (char *)"new_DataObjectComposite", (PyCFunction)_wrap_new_DataObjectComposite, METH_NOARGS, NULL},
36516 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
36517 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
36518 { (char *)"DataObjectComposite_swiginit", DataObjectComposite_swiginit, METH_VARARGS, NULL},
36519 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36520 { (char *)"TextDataObject_GetTextLength", (PyCFunction)_wrap_TextDataObject_GetTextLength, METH_O, NULL},
36521 { (char *)"TextDataObject_GetText", (PyCFunction)_wrap_TextDataObject_GetText, METH_O, NULL},
36522 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
36523 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
36524 { (char *)"TextDataObject_swiginit", TextDataObject_swiginit, METH_VARARGS, NULL},
36525 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36526 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36527 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
36528 { (char *)"PyTextDataObject_swiginit", PyTextDataObject_swiginit, METH_VARARGS, NULL},
36529 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36530 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction)_wrap_BitmapDataObject_GetBitmap, METH_O, NULL},
36531 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
36532 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
36533 { (char *)"BitmapDataObject_swiginit", BitmapDataObject_swiginit, METH_VARARGS, NULL},
36534 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36535 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36536 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
36537 { (char *)"PyBitmapDataObject_swiginit", PyBitmapDataObject_swiginit, METH_VARARGS, NULL},
36538 { (char *)"new_FileDataObject", (PyCFunction)_wrap_new_FileDataObject, METH_NOARGS, NULL},
36539 { (char *)"FileDataObject_GetFilenames", (PyCFunction)_wrap_FileDataObject_GetFilenames, METH_O, NULL},
36540 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
36541 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
36542 { (char *)"FileDataObject_swiginit", FileDataObject_swiginit, METH_VARARGS, NULL},
36543 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
36544 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36545 { (char *)"CustomDataObject_GetSize", (PyCFunction)_wrap_CustomDataObject_GetSize, METH_O, NULL},
36546 { (char *)"CustomDataObject_GetData", (PyCFunction)_wrap_CustomDataObject_GetData, METH_O, NULL},
36547 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
36548 { (char *)"CustomDataObject_swiginit", CustomDataObject_swiginit, METH_VARARGS, NULL},
36549 { (char *)"new_URLDataObject", (PyCFunction)_wrap_new_URLDataObject, METH_NOARGS, NULL},
36550 { (char *)"URLDataObject_GetURL", (PyCFunction)_wrap_URLDataObject_GetURL, METH_O, NULL},
36551 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
36552 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
36553 { (char *)"URLDataObject_swiginit", URLDataObject_swiginit, METH_VARARGS, NULL},
36554 { (char *)"new_MetafileDataObject", (PyCFunction)_wrap_new_MetafileDataObject, METH_NOARGS, NULL},
36555 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
36556 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction)_wrap_MetafileDataObject_GetMetafile, METH_O, NULL},
36557 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
36558 { (char *)"MetafileDataObject_swiginit", MetafileDataObject_swiginit, METH_VARARGS, NULL},
36559 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
36560 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
36561 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36562 { (char *)"delete_DropSource", (PyCFunction)_wrap_delete_DropSource, METH_O, NULL},
36563 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36564 { (char *)"DropSource_GetDataObject", (PyCFunction)_wrap_DropSource_GetDataObject, METH_O, NULL},
36565 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
36566 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36567 { (char *)"DropSource_GiveFeedback", (PyCFunction) _wrap_DropSource_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
36568 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
36569 { (char *)"DropSource_swiginit", DropSource_swiginit, METH_VARARGS, NULL},
36570 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
36571 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36572 { (char *)"delete_DropTarget", (PyCFunction)_wrap_delete_DropTarget, METH_O, NULL},
36573 { (char *)"DropTarget_GetDataObject", (PyCFunction)_wrap_DropTarget_GetDataObject, METH_O, NULL},
36574 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
36575 { (char *)"DropTarget_OnEnter", (PyCFunction) _wrap_DropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36576 { (char *)"DropTarget_OnDragOver", (PyCFunction) _wrap_DropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36577 { (char *)"DropTarget_OnLeave", (PyCFunction)_wrap_DropTarget_OnLeave, METH_O, NULL},
36578 { (char *)"DropTarget_OnDrop", (PyCFunction) _wrap_DropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36579 { (char *)"DropTarget_GetData", (PyCFunction)_wrap_DropTarget_GetData, METH_O, NULL},
36580 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
36581 { (char *)"DropTarget_GetDefaultAction", (PyCFunction)_wrap_DropTarget_GetDefaultAction, METH_O, NULL},
36582 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
36583 { (char *)"DropTarget_swiginit", DropTarget_swiginit, METH_VARARGS, NULL},
36584 { (char *)"new_TextDropTarget", (PyCFunction)_wrap_new_TextDropTarget, METH_NOARGS, NULL},
36585 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36586 { (char *)"TextDropTarget_OnDropText", (PyCFunction) _wrap_TextDropTarget_OnDropText, METH_VARARGS | METH_KEYWORDS, NULL},
36587 { (char *)"TextDropTarget_OnEnter", (PyCFunction) _wrap_TextDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36588 { (char *)"TextDropTarget_OnDragOver", (PyCFunction) _wrap_TextDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36589 { (char *)"TextDropTarget_OnLeave", (PyCFunction)_wrap_TextDropTarget_OnLeave, METH_O, NULL},
36590 { (char *)"TextDropTarget_OnDrop", (PyCFunction) _wrap_TextDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36591 { (char *)"TextDropTarget_OnData", (PyCFunction) _wrap_TextDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36592 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
36593 { (char *)"TextDropTarget_swiginit", TextDropTarget_swiginit, METH_VARARGS, NULL},
36594 { (char *)"new_FileDropTarget", (PyCFunction)_wrap_new_FileDropTarget, METH_NOARGS, NULL},
36595 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
36596 { (char *)"FileDropTarget_OnDropFiles", (PyCFunction) _wrap_FileDropTarget_OnDropFiles, METH_VARARGS | METH_KEYWORDS, NULL},
36597 { (char *)"FileDropTarget_OnEnter", (PyCFunction) _wrap_FileDropTarget_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
36598 { (char *)"FileDropTarget_OnDragOver", (PyCFunction) _wrap_FileDropTarget_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
36599 { (char *)"FileDropTarget_OnLeave", (PyCFunction)_wrap_FileDropTarget_OnLeave, METH_O, NULL},
36600 { (char *)"FileDropTarget_OnDrop", (PyCFunction) _wrap_FileDropTarget_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
36601 { (char *)"FileDropTarget_OnData", (PyCFunction) _wrap_FileDropTarget_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
36602 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
36603 { (char *)"FileDropTarget_swiginit", FileDropTarget_swiginit, METH_VARARGS, NULL},
36604 { (char *)"new_Clipboard", (PyCFunction)_wrap_new_Clipboard, METH_NOARGS, NULL},
36605 { (char *)"delete_Clipboard", (PyCFunction)_wrap_delete_Clipboard, METH_O, NULL},
36606 { (char *)"Clipboard_Open", (PyCFunction)_wrap_Clipboard_Open, METH_O, NULL},
36607 { (char *)"Clipboard_Close", (PyCFunction)_wrap_Clipboard_Close, METH_O, NULL},
36608 { (char *)"Clipboard_IsOpened", (PyCFunction)_wrap_Clipboard_IsOpened, METH_O, NULL},
36609 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
36610 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
36611 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
36612 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
36613 { (char *)"Clipboard_Clear", (PyCFunction)_wrap_Clipboard_Clear, METH_O, NULL},
36614 { (char *)"Clipboard_Flush", (PyCFunction)_wrap_Clipboard_Flush, METH_O, NULL},
36615 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
36616 { (char *)"Clipboard_Get", (PyCFunction)_wrap_Clipboard_Get, METH_NOARGS, NULL},
36617 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
36618 { (char *)"Clipboard_swiginit", Clipboard_swiginit, METH_VARARGS, NULL},
36619 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
36620 { (char *)"delete_ClipboardLocker", (PyCFunction)_wrap_delete_ClipboardLocker, METH_O, NULL},
36621 { (char *)"ClipboardLocker___nonzero__", (PyCFunction)_wrap_ClipboardLocker___nonzero__, METH_O, NULL},
36622 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
36623 { (char *)"ClipboardLocker_swiginit", ClipboardLocker_swiginit, METH_VARARGS, NULL},
36624 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
36625 { (char *)"delete_VideoMode", (PyCFunction)_wrap_delete_VideoMode, METH_O, NULL},
36626 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
36627 { (char *)"VideoMode_GetWidth", (PyCFunction)_wrap_VideoMode_GetWidth, METH_O, NULL},
36628 { (char *)"VideoMode_GetHeight", (PyCFunction)_wrap_VideoMode_GetHeight, METH_O, NULL},
36629 { (char *)"VideoMode_GetDepth", (PyCFunction)_wrap_VideoMode_GetDepth, METH_O, NULL},
36630 { (char *)"VideoMode_IsOk", (PyCFunction)_wrap_VideoMode_IsOk, METH_O, NULL},
36631 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
36632 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
36633 { (char *)"VideoMode_w_set", _wrap_VideoMode_w_set, METH_VARARGS, NULL},
36634 { (char *)"VideoMode_w_get", (PyCFunction)_wrap_VideoMode_w_get, METH_O, NULL},
36635 { (char *)"VideoMode_h_set", _wrap_VideoMode_h_set, METH_VARARGS, NULL},
36636 { (char *)"VideoMode_h_get", (PyCFunction)_wrap_VideoMode_h_get, METH_O, NULL},
36637 { (char *)"VideoMode_bpp_set", _wrap_VideoMode_bpp_set, METH_VARARGS, NULL},
36638 { (char *)"VideoMode_bpp_get", (PyCFunction)_wrap_VideoMode_bpp_get, METH_O, NULL},
36639 { (char *)"VideoMode_refresh_set", _wrap_VideoMode_refresh_set, METH_VARARGS, NULL},
36640 { (char *)"VideoMode_refresh_get", (PyCFunction)_wrap_VideoMode_refresh_get, METH_O, NULL},
36641 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
36642 { (char *)"VideoMode_swiginit", VideoMode_swiginit, METH_VARARGS, NULL},
36643 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
36644 { (char *)"delete_Display", (PyCFunction)_wrap_delete_Display, METH_O, NULL},
36645 { (char *)"Display_GetCount", (PyCFunction)_wrap_Display_GetCount, METH_NOARGS, NULL},
36646 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
36647 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
36648 { (char *)"Display_IsOk", (PyCFunction)_wrap_Display_IsOk, METH_O, NULL},
36649 { (char *)"Display_GetGeometry", (PyCFunction)_wrap_Display_GetGeometry, METH_O, NULL},
36650 { (char *)"Display_GetName", (PyCFunction)_wrap_Display_GetName, METH_O, NULL},
36651 { (char *)"Display_IsPrimary", (PyCFunction)_wrap_Display_IsPrimary, METH_O, NULL},
36652 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
36653 { (char *)"Display_GetCurrentMode", (PyCFunction)_wrap_Display_GetCurrentMode, METH_O, NULL},
36654 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
36655 { (char *)"Display_ResetMode", (PyCFunction)_wrap_Display_ResetMode, METH_O, NULL},
36656 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
36657 { (char *)"Display_swiginit", Display_swiginit, METH_VARARGS, NULL},
36658 { (char *)"StandardPaths_Get", (PyCFunction)_wrap_StandardPaths_Get, METH_NOARGS, NULL},
36659 { (char *)"StandardPaths_GetConfigDir", (PyCFunction)_wrap_StandardPaths_GetConfigDir, METH_O, NULL},
36660 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction)_wrap_StandardPaths_GetUserConfigDir, METH_O, NULL},
36661 { (char *)"StandardPaths_GetDataDir", (PyCFunction)_wrap_StandardPaths_GetDataDir, METH_O, NULL},
36662 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetLocalDataDir, METH_O, NULL},
36663 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction)_wrap_StandardPaths_GetUserDataDir, METH_O, NULL},
36664 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction)_wrap_StandardPaths_GetUserLocalDataDir, METH_O, NULL},
36665 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction)_wrap_StandardPaths_GetPluginsDir, METH_O, NULL},
36666 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
36667 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction)_wrap_StandardPaths_GetInstallPrefix, METH_O, NULL},
36668 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
36669 { NULL, NULL, 0, NULL }
36670 };
36671
36672
36673 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
36674
36675 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
36676 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
36677 }
36678 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
36679 return (void *)((wxEvent *) ((wxMenuEvent *) x));
36680 }
36681 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
36682 return (void *)((wxEvent *) ((wxCloseEvent *) x));
36683 }
36684 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
36685 return (void *)((wxEvent *) ((wxMouseEvent *) x));
36686 }
36687 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
36688 return (void *)((wxEvent *) ((wxEraseEvent *) x));
36689 }
36690 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
36691 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
36692 }
36693 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
36694 return (void *)((wxEvent *) ((wxTimerEvent *) x));
36695 }
36696 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
36697 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
36698 }
36699 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
36700 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
36701 }
36702 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
36703 return (void *)((wxEvent *) ((wxPyEvent *) x));
36704 }
36705 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
36706 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
36707 }
36708 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
36709 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
36710 }
36711 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
36712 return (void *)((wxEvent *) ((wxIdleEvent *) x));
36713 }
36714 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
36715 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
36716 }
36717 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
36718 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
36719 }
36720 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
36721 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
36722 }
36723 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
36724 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
36725 }
36726 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
36727 return (void *)((wxEvent *) ((wxActivateEvent *) x));
36728 }
36729 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
36730 return (void *)((wxEvent *) ((wxSizeEvent *) x));
36731 }
36732 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
36733 return (void *)((wxEvent *) ((wxMoveEvent *) x));
36734 }
36735 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
36736 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
36737 }
36738 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
36739 return (void *)((wxEvent *) ((wxPaintEvent *) x));
36740 }
36741 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
36742 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
36743 }
36744 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
36745 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
36746 }
36747 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
36748 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
36749 }
36750 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
36751 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
36752 }
36753 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
36754 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36755 }
36756 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
36757 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
36758 }
36759 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
36760 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
36761 }
36762 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
36763 return (void *)((wxEvent *) ((wxFocusEvent *) x));
36764 }
36765 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
36766 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
36767 }
36768 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
36769 return (void *)((wxEvent *) ((wxProcessEvent *) x));
36770 }
36771 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
36772 return (void *)((wxEvent *) ((wxShowEvent *) x));
36773 }
36774 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
36775 return (void *)((wxEvent *) ((wxCommandEvent *) x));
36776 }
36777 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
36778 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
36779 }
36780 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
36781 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
36782 }
36783 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
36784 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
36785 }
36786 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
36787 return (void *)((wxEvent *) ((wxKeyEvent *) x));
36788 }
36789 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
36790 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
36791 }
36792 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
36793 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
36794 }
36795 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
36796 return (void *)((wxConfigBase *) ((wxConfig *) x));
36797 }
36798 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
36799 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36800 }
36801 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
36802 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
36803 }
36804 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
36805 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
36806 }
36807 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
36808 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36809 }
36810 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
36811 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
36812 }
36813 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
36814 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
36815 }
36816 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
36817 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
36818 }
36819 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
36820 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36821 }
36822 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
36823 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36824 }
36825 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
36826 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
36827 }
36828 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
36829 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
36830 }
36831 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
36832 return (void *)((wxDataObject *) ((wxURLDataObject *) x));
36833 }
36834 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
36835 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
36836 }
36837 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
36838 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
36839 }
36840 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
36841 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
36842 }
36843 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
36844 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
36845 }
36846 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
36847 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
36848 }
36849 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
36850 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
36851 }
36852 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
36853 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
36854 }
36855 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
36856 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
36857 }
36858 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
36859 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
36860 }
36861 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
36862 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
36863 }
36864 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
36865 return (void *)((wxEvtHandler *) ((wxWindow *) x));
36866 }
36867 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
36868 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
36869 }
36870 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
36871 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
36872 }
36873 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
36874 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
36875 }
36876 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
36877 return (void *)((wxEvtHandler *) ((wxValidator *) x));
36878 }
36879 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
36880 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
36881 }
36882 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
36883 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
36884 }
36885 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
36886 return (void *)((wxEvtHandler *) ((wxMenu *) x));
36887 }
36888 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
36889 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
36890 }
36891 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
36892 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
36893 }
36894 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
36895 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
36896 }
36897 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
36898 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
36899 }
36900 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
36901 return (void *)((wxObject *) ((wxSizerItem *) x));
36902 }
36903 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
36904 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
36905 }
36906 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
36907 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
36908 }
36909 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
36910 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
36911 }
36912 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
36913 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
36914 }
36915 static void *_p_wxSizerTo_p_wxObject(void *x) {
36916 return (void *)((wxObject *) ((wxSizer *) x));
36917 }
36918 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
36919 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
36920 }
36921 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
36922 return (void *)((wxObject *) ((wxFileHistory *) x));
36923 }
36924 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
36925 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
36926 }
36927 static void *_p_wxEventTo_p_wxObject(void *x) {
36928 return (void *)((wxObject *) ((wxEvent *) x));
36929 }
36930 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
36931 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
36932 }
36933 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
36934 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
36935 }
36936 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
36937 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
36938 }
36939 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
36940 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
36941 }
36942 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
36943 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
36944 }
36945 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
36946 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
36947 }
36948 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
36949 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
36950 }
36951 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
36952 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
36953 }
36954 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
36955 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
36956 }
36957 static void *_p_wxControlTo_p_wxObject(void *x) {
36958 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
36959 }
36960 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
36961 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
36962 }
36963 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
36964 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
36965 }
36966 static void *_p_wxFSFileTo_p_wxObject(void *x) {
36967 return (void *)((wxObject *) ((wxFSFile *) x));
36968 }
36969 static void *_p_wxClipboardTo_p_wxObject(void *x) {
36970 return (void *)((wxObject *) ((wxClipboard *) x));
36971 }
36972 static void *_p_wxPySizerTo_p_wxObject(void *x) {
36973 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
36974 }
36975 static void *_p_wxPyEventTo_p_wxObject(void *x) {
36976 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
36977 }
36978 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
36979 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
36980 }
36981 static void *_p_wxShowEventTo_p_wxObject(void *x) {
36982 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
36983 }
36984 static void *_p_wxToolTipTo_p_wxObject(void *x) {
36985 return (void *)((wxObject *) ((wxToolTip *) x));
36986 }
36987 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
36988 return (void *)((wxObject *) ((wxMenuItem *) x));
36989 }
36990 static void *_p_wxDateEventTo_p_wxObject(void *x) {
36991 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
36992 }
36993 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
36994 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
36995 }
36996 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
36997 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
36998 }
36999 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
37000 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
37001 }
37002 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
37003 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
37004 }
37005 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
37006 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
37007 }
37008 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
37009 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
37010 }
37011 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
37012 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
37013 }
37014 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
37015 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
37016 }
37017 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
37018 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
37019 }
37020 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
37021 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
37022 }
37023 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
37024 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
37025 }
37026 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
37027 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
37028 }
37029 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
37030 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
37031 }
37032 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
37033 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
37034 }
37035 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
37036 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
37037 }
37038 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
37039 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
37040 }
37041 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
37042 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
37043 }
37044 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
37045 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
37046 }
37047 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
37048 return (void *)((wxObject *) ((wxImageHandler *) x));
37049 }
37050 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
37051 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
37052 }
37053 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
37054 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
37055 }
37056 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
37057 return (void *)((wxObject *) ((wxEvtHandler *) x));
37058 }
37059 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
37060 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
37061 }
37062 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
37063 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
37064 }
37065 static void *_p_wxImageTo_p_wxObject(void *x) {
37066 return (void *)((wxObject *) ((wxImage *) x));
37067 }
37068 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
37069 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
37070 }
37071 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
37072 return (void *)((wxObject *) ((wxSystemOptions *) x));
37073 }
37074 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
37075 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
37076 }
37077 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
37078 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
37079 }
37080 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
37081 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
37082 }
37083 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
37084 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
37085 }
37086 static void *_p_wxWindowTo_p_wxObject(void *x) {
37087 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
37088 }
37089 static void *_p_wxMenuTo_p_wxObject(void *x) {
37090 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
37091 }
37092 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
37093 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
37094 }
37095 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
37096 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
37097 }
37098 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
37099 return (void *)((wxObject *) ((wxFileSystem *) x));
37100 }
37101 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
37102 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
37103 }
37104 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
37105 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
37106 }
37107 static void *_p_wxPyAppTo_p_wxObject(void *x) {
37108 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
37109 }
37110 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
37111 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
37112 }
37113 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
37114 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
37115 }
37116 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
37117 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
37118 }
37119 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
37120 return (void *)((wxObject *) ((wxBusyInfo *) x));
37121 }
37122 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
37123 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
37124 }
37125 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
37126 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
37127 }
37128 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
37129 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
37130 }
37131 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
37132 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
37133 }
37134 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
37135 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
37136 }
37137 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
37138 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
37139 }
37140 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
37141 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
37142 }
37143 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
37144 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
37145 }
37146 static void *_p_wxValidatorTo_p_wxObject(void *x) {
37147 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
37148 }
37149 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
37150 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
37151 }
37152 static void *_p_wxLogBufferTo_p_wxLog(void *x) {
37153 return (void *)((wxLog *) ((wxLogBuffer *) x));
37154 }
37155 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
37156 return (void *)((wxLog *) ((wxLogStderr *) x));
37157 }
37158 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
37159 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
37160 }
37161 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
37162 return (void *)((wxLog *) ((wxLogWindow *) x));
37163 }
37164 static void *_p_wxLogChainTo_p_wxLog(void *x) {
37165 return (void *)((wxLog *) ((wxLogChain *) x));
37166 }
37167 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
37168 return (void *)((wxLog *) ((wxLogGui *) x));
37169 }
37170 static void *_p_wxPyLogTo_p_wxLog(void *x) {
37171 return (void *)((wxLog *) ((wxPyLog *) x));
37172 }
37173 static void *_p_wxControlTo_p_wxWindow(void *x) {
37174 return (void *)((wxWindow *) ((wxControl *) x));
37175 }
37176 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
37177 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
37178 }
37179 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
37180 return (void *)((wxWindow *) ((wxMenuBar *) x));
37181 }
37182 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
37183 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
37184 }
37185 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
37186 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
37187 }
37188 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
37189 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};
37190 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
37191 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
37192 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
37193 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxLogLevel *", 0, 0, (void*)0, 0};
37194 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
37195 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
37196 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
37197 static swig_type_info _swigt__p_wxBitmapDataObject = {"_p_wxBitmapDataObject", "wxBitmapDataObject *", 0, 0, (void*)0, 0};
37198 static swig_type_info _swigt__p_wxBusyCursor = {"_p_wxBusyCursor", "wxBusyCursor *", 0, 0, (void*)0, 0};
37199 static swig_type_info _swigt__p_wxBusyInfo = {"_p_wxBusyInfo", "wxBusyInfo *", 0, 0, (void*)0, 0};
37200 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
37201 static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};
37202 static swig_type_info _swigt__p_wxClipboard = {"_p_wxClipboard", "wxClipboard *", 0, 0, (void*)0, 0};
37203 static swig_type_info _swigt__p_wxClipboardLocker = {"_p_wxClipboardLocker", "wxClipboardLocker *", 0, 0, (void*)0, 0};
37204 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
37205 static swig_type_info _swigt__p_wxConfig = {"_p_wxConfig", "wxConfig *", 0, 0, (void*)0, 0};
37206 static swig_type_info _swigt__p_wxConfigBase = {"_p_wxConfigBase", "wxConfigBase *", 0, 0, (void*)0, 0};
37207 static swig_type_info _swigt__p_wxConfigPathChanger = {"_p_wxConfigPathChanger", "wxConfigPathChanger *", 0, 0, (void*)0, 0};
37208 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
37209 static swig_type_info _swigt__p_wxCustomDataObject = {"_p_wxCustomDataObject", "wxCustomDataObject *", 0, 0, (void*)0, 0};
37210 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
37211 static swig_type_info _swigt__p_wxDataFormat = {"_p_wxDataFormat", "wxDataFormat *", 0, 0, (void*)0, 0};
37212 static swig_type_info _swigt__p_wxDataObject = {"_p_wxDataObject", "wxDataObject *", 0, 0, (void*)0, 0};
37213 static swig_type_info _swigt__p_wxDataObjectComposite = {"_p_wxDataObjectComposite", "wxDataObjectComposite *", 0, 0, (void*)0, 0};
37214 static swig_type_info _swigt__p_wxDataObjectSimple = {"_p_wxDataObjectSimple", "wxDataObjectSimple *", 0, 0, (void*)0, 0};
37215 static swig_type_info _swigt__p_wxDateSpan = {"_p_wxDateSpan", "wxDateSpan *", 0, 0, (void*)0, 0};
37216 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
37217 static swig_type_info _swigt__p_wxDateTime__TimeZone = {"_p_wxDateTime__TimeZone", "wxDateTime::TimeZone *", 0, 0, (void*)0, 0};
37218 static swig_type_info _swigt__p_wxDisplay = {"_p_wxDisplay", "wxDisplay *", 0, 0, (void*)0, 0};
37219 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
37220 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
37221 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};
37222 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};
37223 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};
37224 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};
37225 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};
37226 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};
37227 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};
37228 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};
37229 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};
37230 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", 0, 0, 0, 0, 0};
37231 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};
37232 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};
37233 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};
37234 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};
37235 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};
37236 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};
37237 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};
37238 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};
37239 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};
37240 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};
37241 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};
37242 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};
37243 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};
37244 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};
37245 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};
37246 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};
37247 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};
37248 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};
37249 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};
37250 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};
37251 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", 0, 0, 0, 0, 0};
37252 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};
37253 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};
37254 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};
37255 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", 0, 0, 0, 0, 0};
37256 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", 0, 0, 0, 0, 0};
37257 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
37258 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", 0, 0, 0, 0, 0};
37259 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};
37260 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};
37261 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};
37262 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", 0, 0, 0, 0, 0};
37263 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};
37264 static swig_type_info _swigt__p_wxFileConfig = {"_p_wxFileConfig", "wxFileConfig *", 0, 0, (void*)0, 0};
37265 static swig_type_info _swigt__p_wxFileDataObject = {"_p_wxFileDataObject", "wxFileDataObject *", 0, 0, (void*)0, 0};
37266 static swig_type_info _swigt__p_wxFileHistory = {"_p_wxFileHistory", "wxFileHistory *", 0, 0, (void*)0, 0};
37267 static swig_type_info _swigt__p_wxFileType = {"_p_wxFileType", "wxFileType *", 0, 0, (void*)0, 0};
37268 static swig_type_info _swigt__p_wxFileTypeInfo = {"_p_wxFileTypeInfo", "wxFileTypeInfo *", 0, 0, (void*)0, 0};
37269 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
37270 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
37271 static swig_type_info _swigt__p_wxIcon = {"_p_wxIcon", "wxIcon *", 0, 0, (void*)0, 0};
37272 static swig_type_info _swigt__p_wxJoystick = {"_p_wxJoystick", "wxJoystick *", 0, 0, (void*)0, 0};
37273 static swig_type_info _swigt__p_wxJoystickEvent = {"_p_wxJoystickEvent", "wxJoystickEvent *", 0, 0, (void*)0, 0};
37274 static swig_type_info _swigt__p_wxKillError = {"_p_wxKillError", "enum wxKillError *|wxKillError *", 0, 0, (void*)0, 0};
37275 static swig_type_info _swigt__p_wxLog = {"_p_wxLog", "wxLog *", 0, 0, (void*)0, 0};
37276 static swig_type_info _swigt__p_wxLogBuffer = {"_p_wxLogBuffer", "wxLogBuffer *", 0, 0, (void*)0, 0};
37277 static swig_type_info _swigt__p_wxLogChain = {"_p_wxLogChain", "wxLogChain *", 0, 0, (void*)0, 0};
37278 static swig_type_info _swigt__p_wxLogGui = {"_p_wxLogGui", "wxLogGui *", 0, 0, (void*)0, 0};
37279 static swig_type_info _swigt__p_wxLogNull = {"_p_wxLogNull", "wxLogNull *", 0, 0, (void*)0, 0};
37280 static swig_type_info _swigt__p_wxLogStderr = {"_p_wxLogStderr", "wxLogStderr *", 0, 0, (void*)0, 0};
37281 static swig_type_info _swigt__p_wxLogTextCtrl = {"_p_wxLogTextCtrl", "wxLogTextCtrl *", 0, 0, (void*)0, 0};
37282 static swig_type_info _swigt__p_wxLogWindow = {"_p_wxLogWindow", "wxLogWindow *", 0, 0, (void*)0, 0};
37283 static swig_type_info _swigt__p_wxMemorySize = {"_p_wxMemorySize", "wxMemorySize *", 0, 0, (void*)0, 0};
37284 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
37285 static swig_type_info _swigt__p_wxMetafile = {"_p_wxMetafile", "wxMetafile *", 0, 0, (void*)0, 0};
37286 static swig_type_info _swigt__p_wxMetafileDataObject = {"_p_wxMetafileDataObject", "wxMetafileDataObject *", 0, 0, (void*)0, 0};
37287 static swig_type_info _swigt__p_wxMimeTypesManager = {"_p_wxMimeTypesManager", "wxMimeTypesManager *", 0, 0, (void*)0, 0};
37288 static swig_type_info _swigt__p_wxMouseState = {"_p_wxMouseState", "wxMouseState *", 0, 0, (void*)0, 0};
37289 static swig_type_info _swigt__p_wxMutexGuiLocker = {"_p_wxMutexGuiLocker", "wxMutexGuiLocker *", 0, 0, (void*)0, 0};
37290 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
37291 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};
37292 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};
37293 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};
37294 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};
37295 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};
37296 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};
37297 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};
37298 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};
37299 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};
37300 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};
37301 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};
37302 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};
37303 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};
37304 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};
37305 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};
37306 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};
37307 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};
37308 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};
37309 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};
37310 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};
37311 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};
37312 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};
37313 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};
37314 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};
37315 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};
37316 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};
37317 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};
37318 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};
37319 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", 0, 0, 0, 0, 0};
37320 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};
37321 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
37322 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
37323 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
37324 static swig_type_info _swigt__p_wxProcessEvent = {"_p_wxProcessEvent", "wxProcessEvent *", 0, 0, (void*)0, 0};
37325 static swig_type_info _swigt__p_wxPyArtProvider = {"_p_wxPyArtProvider", "wxPyArtProvider *", 0, 0, (void*)0, 0};
37326 static swig_type_info _swigt__p_wxPyBitmapDataObject = {"_p_wxPyBitmapDataObject", "wxPyBitmapDataObject *", 0, 0, (void*)0, 0};
37327 static swig_type_info _swigt__p_wxPyDataObjectSimple = {"_p_wxPyDataObjectSimple", "wxPyDataObjectSimple *", 0, 0, (void*)0, 0};
37328 static swig_type_info _swigt__p_wxPyDropSource = {"_p_wxPyDropSource", "wxPyDropSource *", 0, 0, (void*)0, 0};
37329 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
37330 static swig_type_info _swigt__p_wxPyFileDropTarget = {"_p_wxPyFileDropTarget", "wxPyFileDropTarget *", 0, 0, (void*)0, 0};
37331 static swig_type_info _swigt__p_wxPyLog = {"_p_wxPyLog", "wxPyLog *", 0, 0, (void*)0, 0};
37332 static swig_type_info _swigt__p_wxPyProcess = {"_p_wxPyProcess", "wxPyProcess *", 0, 0, (void*)0, 0};
37333 static swig_type_info _swigt__p_wxPyTextDataObject = {"_p_wxPyTextDataObject", "wxPyTextDataObject *", 0, 0, (void*)0, 0};
37334 static swig_type_info _swigt__p_wxPyTextDropTarget = {"_p_wxPyTextDropTarget", "wxPyTextDropTarget *", 0, 0, (void*)0, 0};
37335 static swig_type_info _swigt__p_wxPyTimer = {"_p_wxPyTimer", "wxPyTimer *", 0, 0, (void*)0, 0};
37336 static swig_type_info _swigt__p_wxPyTipProvider = {"_p_wxPyTipProvider", "wxPyTipProvider *", 0, 0, (void*)0, 0};
37337 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
37338 static swig_type_info _swigt__p_wxSingleInstanceChecker = {"_p_wxSingleInstanceChecker", "wxSingleInstanceChecker *", 0, 0, (void*)0, 0};
37339 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
37340 static swig_type_info _swigt__p_wxSound = {"_p_wxSound", "wxSound *", 0, 0, (void*)0, 0};
37341 static swig_type_info _swigt__p_wxStandardPaths = {"_p_wxStandardPaths", "wxStandardPaths *", 0, 0, (void*)0, 0};
37342 static swig_type_info _swigt__p_wxStopWatch = {"_p_wxStopWatch", "wxStopWatch *", 0, 0, (void*)0, 0};
37343 static swig_type_info _swigt__p_wxString = {"_p_wxString", "wxString *", 0, 0, (void*)0, 0};
37344 static swig_type_info _swigt__p_wxSystemOptions = {"_p_wxSystemOptions", "wxSystemOptions *", 0, 0, (void*)0, 0};
37345 static swig_type_info _swigt__p_wxSystemSettings = {"_p_wxSystemSettings", "wxSystemSettings *", 0, 0, (void*)0, 0};
37346 static swig_type_info _swigt__p_wxTextCtrl = {"_p_wxTextCtrl", "wxTextCtrl *", 0, 0, (void*)0, 0};
37347 static swig_type_info _swigt__p_wxTextDataObject = {"_p_wxTextDataObject", "wxTextDataObject *", 0, 0, (void*)0, 0};
37348 static swig_type_info _swigt__p_wxTimeSpan = {"_p_wxTimeSpan", "wxTimeSpan *", 0, 0, (void*)0, 0};
37349 static swig_type_info _swigt__p_wxTimer = {"_p_wxTimer", "wxTimer *", 0, 0, (void*)0, 0};
37350 static swig_type_info _swigt__p_wxTimerEvent = {"_p_wxTimerEvent", "wxTimerEvent *", 0, 0, (void*)0, 0};
37351 static swig_type_info _swigt__p_wxTimerRunner = {"_p_wxTimerRunner", "wxTimerRunner *", 0, 0, (void*)0, 0};
37352 static swig_type_info _swigt__p_wxTipProvider = {"_p_wxTipProvider", "wxTipProvider *", 0, 0, (void*)0, 0};
37353 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
37354 static swig_type_info _swigt__p_wxURLDataObject = {"_p_wxURLDataObject", "wxURLDataObject *", 0, 0, (void*)0, 0};
37355 static swig_type_info _swigt__p_wxVideoMode = {"_p_wxVideoMode", "wxVideoMode *", 0, 0, (void*)0, 0};
37356 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
37357 static swig_type_info _swigt__p_wxWindowDisabler = {"_p_wxWindowDisabler", "wxWindowDisabler *", 0, 0, (void*)0, 0};
37358
37359 static swig_type_info *swig_type_initial[] = {
37360 &_swigt__p_char,
37361 &_swigt__p_form_ops_t,
37362 &_swigt__p_int,
37363 &_swigt__p_unsigned_char,
37364 &_swigt__p_unsigned_int,
37365 &_swigt__p_unsigned_long,
37366 &_swigt__p_void,
37367 &_swigt__p_wxANIHandler,
37368 &_swigt__p_wxAcceleratorTable,
37369 &_swigt__p_wxActivateEvent,
37370 &_swigt__p_wxArrayString,
37371 &_swigt__p_wxBMPHandler,
37372 &_swigt__p_wxBitmap,
37373 &_swigt__p_wxBitmapDataObject,
37374 &_swigt__p_wxBoxSizer,
37375 &_swigt__p_wxBusyCursor,
37376 &_swigt__p_wxBusyInfo,
37377 &_swigt__p_wxCURHandler,
37378 &_swigt__p_wxCaret,
37379 &_swigt__p_wxChar,
37380 &_swigt__p_wxChildFocusEvent,
37381 &_swigt__p_wxClipboard,
37382 &_swigt__p_wxClipboardLocker,
37383 &_swigt__p_wxCloseEvent,
37384 &_swigt__p_wxColour,
37385 &_swigt__p_wxCommandEvent,
37386 &_swigt__p_wxConfig,
37387 &_swigt__p_wxConfigBase,
37388 &_swigt__p_wxConfigPathChanger,
37389 &_swigt__p_wxContextMenuEvent,
37390 &_swigt__p_wxControl,
37391 &_swigt__p_wxControlWithItems,
37392 &_swigt__p_wxCursor,
37393 &_swigt__p_wxCustomDataObject,
37394 &_swigt__p_wxDC,
37395 &_swigt__p_wxDataFormat,
37396 &_swigt__p_wxDataObject,
37397 &_swigt__p_wxDataObjectComposite,
37398 &_swigt__p_wxDataObjectSimple,
37399 &_swigt__p_wxDateEvent,
37400 &_swigt__p_wxDateSpan,
37401 &_swigt__p_wxDateTime,
37402 &_swigt__p_wxDateTime__TimeZone,
37403 &_swigt__p_wxDisplay,
37404 &_swigt__p_wxDisplayChangedEvent,
37405 &_swigt__p_wxDropFilesEvent,
37406 &_swigt__p_wxDuplexMode,
37407 &_swigt__p_wxEraseEvent,
37408 &_swigt__p_wxEvent,
37409 &_swigt__p_wxEvtHandler,
37410 &_swigt__p_wxFSFile,
37411 &_swigt__p_wxFileConfig,
37412 &_swigt__p_wxFileDataObject,
37413 &_swigt__p_wxFileHistory,
37414 &_swigt__p_wxFileSystem,
37415 &_swigt__p_wxFileType,
37416 &_swigt__p_wxFileTypeInfo,
37417 &_swigt__p_wxFlexGridSizer,
37418 &_swigt__p_wxFocusEvent,
37419 &_swigt__p_wxFont,
37420 &_swigt__p_wxFrame,
37421 &_swigt__p_wxGBSizerItem,
37422 &_swigt__p_wxGIFHandler,
37423 &_swigt__p_wxGridBagSizer,
37424 &_swigt__p_wxGridSizer,
37425 &_swigt__p_wxICOHandler,
37426 &_swigt__p_wxIcon,
37427 &_swigt__p_wxIconizeEvent,
37428 &_swigt__p_wxIdleEvent,
37429 &_swigt__p_wxImage,
37430 &_swigt__p_wxImageHandler,
37431 &_swigt__p_wxIndividualLayoutConstraint,
37432 &_swigt__p_wxInitDialogEvent,
37433 &_swigt__p_wxJPEGHandler,
37434 &_swigt__p_wxJoystick,
37435 &_swigt__p_wxJoystickEvent,
37436 &_swigt__p_wxKeyEvent,
37437 &_swigt__p_wxKillError,
37438 &_swigt__p_wxLayoutConstraints,
37439 &_swigt__p_wxLog,
37440 &_swigt__p_wxLogBuffer,
37441 &_swigt__p_wxLogChain,
37442 &_swigt__p_wxLogGui,
37443 &_swigt__p_wxLogNull,
37444 &_swigt__p_wxLogStderr,
37445 &_swigt__p_wxLogTextCtrl,
37446 &_swigt__p_wxLogWindow,
37447 &_swigt__p_wxMaximizeEvent,
37448 &_swigt__p_wxMemorySize,
37449 &_swigt__p_wxMenu,
37450 &_swigt__p_wxMenuBar,
37451 &_swigt__p_wxMenuEvent,
37452 &_swigt__p_wxMenuItem,
37453 &_swigt__p_wxMetafile,
37454 &_swigt__p_wxMetafileDataObject,
37455 &_swigt__p_wxMimeTypesManager,
37456 &_swigt__p_wxMouseCaptureChangedEvent,
37457 &_swigt__p_wxMouseEvent,
37458 &_swigt__p_wxMouseState,
37459 &_swigt__p_wxMoveEvent,
37460 &_swigt__p_wxMutexGuiLocker,
37461 &_swigt__p_wxNavigationKeyEvent,
37462 &_swigt__p_wxNcPaintEvent,
37463 &_swigt__p_wxNotifyEvent,
37464 &_swigt__p_wxObject,
37465 &_swigt__p_wxOutputStream,
37466 &_swigt__p_wxPCXHandler,
37467 &_swigt__p_wxPNGHandler,
37468 &_swigt__p_wxPNMHandler,
37469 &_swigt__p_wxPaintEvent,
37470 &_swigt__p_wxPaletteChangedEvent,
37471 &_swigt__p_wxPaperSize,
37472 &_swigt__p_wxPoint,
37473 &_swigt__p_wxProcessEvent,
37474 &_swigt__p_wxPyApp,
37475 &_swigt__p_wxPyArtProvider,
37476 &_swigt__p_wxPyBitmapDataObject,
37477 &_swigt__p_wxPyCommandEvent,
37478 &_swigt__p_wxPyDataObjectSimple,
37479 &_swigt__p_wxPyDropSource,
37480 &_swigt__p_wxPyDropTarget,
37481 &_swigt__p_wxPyEvent,
37482 &_swigt__p_wxPyFileDropTarget,
37483 &_swigt__p_wxPyImageHandler,
37484 &_swigt__p_wxPyLog,
37485 &_swigt__p_wxPyProcess,
37486 &_swigt__p_wxPySizer,
37487 &_swigt__p_wxPyTextDataObject,
37488 &_swigt__p_wxPyTextDropTarget,
37489 &_swigt__p_wxPyTimer,
37490 &_swigt__p_wxPyTipProvider,
37491 &_swigt__p_wxPyValidator,
37492 &_swigt__p_wxQueryNewPaletteEvent,
37493 &_swigt__p_wxRect,
37494 &_swigt__p_wxScrollEvent,
37495 &_swigt__p_wxScrollWinEvent,
37496 &_swigt__p_wxSetCursorEvent,
37497 &_swigt__p_wxShowEvent,
37498 &_swigt__p_wxSingleInstanceChecker,
37499 &_swigt__p_wxSize,
37500 &_swigt__p_wxSizeEvent,
37501 &_swigt__p_wxSizer,
37502 &_swigt__p_wxSizerItem,
37503 &_swigt__p_wxSound,
37504 &_swigt__p_wxStandardPaths,
37505 &_swigt__p_wxStaticBoxSizer,
37506 &_swigt__p_wxStdDialogButtonSizer,
37507 &_swigt__p_wxStopWatch,
37508 &_swigt__p_wxString,
37509 &_swigt__p_wxSysColourChangedEvent,
37510 &_swigt__p_wxSystemOptions,
37511 &_swigt__p_wxSystemSettings,
37512 &_swigt__p_wxTIFFHandler,
37513 &_swigt__p_wxTextCtrl,
37514 &_swigt__p_wxTextDataObject,
37515 &_swigt__p_wxTimeSpan,
37516 &_swigt__p_wxTimer,
37517 &_swigt__p_wxTimerEvent,
37518 &_swigt__p_wxTimerRunner,
37519 &_swigt__p_wxTipProvider,
37520 &_swigt__p_wxToolTip,
37521 &_swigt__p_wxURLDataObject,
37522 &_swigt__p_wxUpdateUIEvent,
37523 &_swigt__p_wxValidator,
37524 &_swigt__p_wxVideoMode,
37525 &_swigt__p_wxWindow,
37526 &_swigt__p_wxWindowCreateEvent,
37527 &_swigt__p_wxWindowDestroyEvent,
37528 &_swigt__p_wxWindowDisabler,
37529 &_swigt__p_wxXPMHandler,
37530 };
37531
37532 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
37533 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
37534 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
37535 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
37536 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
37537 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
37538 static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
37539 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
37540 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
37541 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}};
37542 static swig_cast_info _swigc__p_wxBusyCursor[] = { {&_swigt__p_wxBusyCursor, 0, 0, 0},{0, 0, 0, 0}};
37543 static swig_cast_info _swigc__p_wxBusyInfo[] = { {&_swigt__p_wxBusyInfo, 0, 0, 0},{0, 0, 0, 0}};
37544 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
37545 static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};
37546 static swig_cast_info _swigc__p_wxClipboard[] = { {&_swigt__p_wxClipboard, 0, 0, 0},{0, 0, 0, 0}};
37547 static swig_cast_info _swigc__p_wxClipboardLocker[] = { {&_swigt__p_wxClipboardLocker, 0, 0, 0},{0, 0, 0, 0}};
37548 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
37549 static swig_cast_info _swigc__p_wxConfig[] = { {&_swigt__p_wxConfig, 0, 0, 0},{0, 0, 0, 0}};
37550 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}};
37551 static swig_cast_info _swigc__p_wxConfigPathChanger[] = { {&_swigt__p_wxConfigPathChanger, 0, 0, 0},{0, 0, 0, 0}};
37552 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
37553 static swig_cast_info _swigc__p_wxCustomDataObject[] = { {&_swigt__p_wxCustomDataObject, 0, 0, 0},{0, 0, 0, 0}};
37554 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
37555 static swig_cast_info _swigc__p_wxDataFormat[] = { {&_swigt__p_wxDataFormat, 0, 0, 0},{0, 0, 0, 0}};
37556 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}};
37557 static swig_cast_info _swigc__p_wxDataObjectComposite[] = { {&_swigt__p_wxDataObjectComposite, 0, 0, 0},{0, 0, 0, 0}};
37558 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}};
37559 static swig_cast_info _swigc__p_wxDateSpan[] = { {&_swigt__p_wxDateSpan, 0, 0, 0},{0, 0, 0, 0}};
37560 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
37561 static swig_cast_info _swigc__p_wxDateTime__TimeZone[] = { {&_swigt__p_wxDateTime__TimeZone, 0, 0, 0},{0, 0, 0, 0}};
37562 static swig_cast_info _swigc__p_wxDisplay[] = { {&_swigt__p_wxDisplay, 0, 0, 0},{0, 0, 0, 0}};
37563 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
37564 static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37565 static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
37566 static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
37567 static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
37568 static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
37569 static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
37570 static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
37571 static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
37572 static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
37573 static swig_cast_info _swigc__p_wxNotifyEvent[] = {{&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
37574 static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
37575 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
37576 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
37577 static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37578 static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37579 static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
37580 static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
37581 static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
37582 static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
37583 static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37584 static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
37585 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
37586 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37587 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37588 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37589 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
37590 static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
37591 static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37592 static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
37593 static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
37594 static swig_cast_info _swigc__p_wxCommandEvent[] = {{&_swigt__p_wxCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37595 static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
37596 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
37597 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37598 static swig_cast_info _swigc__p_wxKeyEvent[] = {{&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
37599 static swig_cast_info _swigc__p_wxScrollWinEvent[] = {{&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
37600 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_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_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}};
37601 static swig_cast_info _swigc__p_wxControl[] = {{&_swigt__p_wxControl, 0, 0, 0},{0, 0, 0, 0}};
37602 static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
37603 static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
37604 static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
37605 static swig_cast_info _swigc__p_wxValidator[] = {{&_swigt__p_wxValidator, 0, 0, 0},{0, 0, 0, 0}};
37606 static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
37607 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}};
37608 static swig_cast_info _swigc__p_wxFileConfig[] = { {&_swigt__p_wxFileConfig, 0, 0, 0},{0, 0, 0, 0}};
37609 static swig_cast_info _swigc__p_wxFileDataObject[] = { {&_swigt__p_wxFileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37610 static swig_cast_info _swigc__p_wxFileHistory[] = { {&_swigt__p_wxFileHistory, 0, 0, 0},{0, 0, 0, 0}};
37611 static swig_cast_info _swigc__p_wxFileType[] = { {&_swigt__p_wxFileType, 0, 0, 0},{0, 0, 0, 0}};
37612 static swig_cast_info _swigc__p_wxFileTypeInfo[] = { {&_swigt__p_wxFileTypeInfo, 0, 0, 0},{0, 0, 0, 0}};
37613 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
37614 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
37615 static swig_cast_info _swigc__p_wxIcon[] = { {&_swigt__p_wxIcon, 0, 0, 0},{0, 0, 0, 0}};
37616 static swig_cast_info _swigc__p_wxJoystick[] = { {&_swigt__p_wxJoystick, 0, 0, 0},{0, 0, 0, 0}};
37617 static swig_cast_info _swigc__p_wxJoystickEvent[] = { {&_swigt__p_wxJoystickEvent, 0, 0, 0},{0, 0, 0, 0}};
37618 static swig_cast_info _swigc__p_wxKillError[] = { {&_swigt__p_wxKillError, 0, 0, 0},{0, 0, 0, 0}};
37619 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}};
37620 static swig_cast_info _swigc__p_wxLogBuffer[] = { {&_swigt__p_wxLogBuffer, 0, 0, 0},{0, 0, 0, 0}};
37621 static swig_cast_info _swigc__p_wxLogChain[] = { {&_swigt__p_wxLogChain, 0, 0, 0},{0, 0, 0, 0}};
37622 static swig_cast_info _swigc__p_wxLogGui[] = { {&_swigt__p_wxLogGui, 0, 0, 0},{0, 0, 0, 0}};
37623 static swig_cast_info _swigc__p_wxLogNull[] = { {&_swigt__p_wxLogNull, 0, 0, 0},{0, 0, 0, 0}};
37624 static swig_cast_info _swigc__p_wxLogStderr[] = { {&_swigt__p_wxLogStderr, 0, 0, 0},{0, 0, 0, 0}};
37625 static swig_cast_info _swigc__p_wxLogTextCtrl[] = { {&_swigt__p_wxLogTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37626 static swig_cast_info _swigc__p_wxLogWindow[] = { {&_swigt__p_wxLogWindow, 0, 0, 0},{0, 0, 0, 0}};
37627 static swig_cast_info _swigc__p_wxMemorySize[] = { {&_swigt__p_wxMemorySize, 0, 0, 0},{0, 0, 0, 0}};
37628 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
37629 static swig_cast_info _swigc__p_wxMetafile[] = { {&_swigt__p_wxMetafile, 0, 0, 0},{0, 0, 0, 0}};
37630 static swig_cast_info _swigc__p_wxMetafileDataObject[] = { {&_swigt__p_wxMetafileDataObject, 0, 0, 0},{0, 0, 0, 0}};
37631 static swig_cast_info _swigc__p_wxMimeTypesManager[] = { {&_swigt__p_wxMimeTypesManager, 0, 0, 0},{0, 0, 0, 0}};
37632 static swig_cast_info _swigc__p_wxMouseState[] = { {&_swigt__p_wxMouseState, 0, 0, 0},{0, 0, 0, 0}};
37633 static swig_cast_info _swigc__p_wxMutexGuiLocker[] = { {&_swigt__p_wxMutexGuiLocker, 0, 0, 0},{0, 0, 0, 0}};
37634 static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
37635 static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37636 static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};
37637 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
37638 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37639 static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
37640 static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};
37641 static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
37642 static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37643 static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
37644 static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
37645 static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
37646 static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
37647 static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};
37648 static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};
37649 static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37650 static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
37651 static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
37652 static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
37653 static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};
37654 static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
37655 static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
37656 static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
37657 static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
37658 static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
37659 static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
37660 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
37661 static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
37662 static swig_cast_info _swigc__p_wxImage[] = {{&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
37663 static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
37664 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_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_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_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_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_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxProcessEvent, _p_wxProcessEventTo_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}};
37665 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
37666 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
37667 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
37668 static swig_cast_info _swigc__p_wxProcessEvent[] = { {&_swigt__p_wxProcessEvent, 0, 0, 0},{0, 0, 0, 0}};
37669 static swig_cast_info _swigc__p_wxPyArtProvider[] = { {&_swigt__p_wxPyArtProvider, 0, 0, 0},{0, 0, 0, 0}};
37670 static swig_cast_info _swigc__p_wxPyBitmapDataObject[] = { {&_swigt__p_wxPyBitmapDataObject, 0, 0, 0},{0, 0, 0, 0}};
37671 static swig_cast_info _swigc__p_wxPyDataObjectSimple[] = { {&_swigt__p_wxPyDataObjectSimple, 0, 0, 0},{0, 0, 0, 0}};
37672 static swig_cast_info _swigc__p_wxPyDropSource[] = { {&_swigt__p_wxPyDropSource, 0, 0, 0},{0, 0, 0, 0}};
37673 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}};
37674 static swig_cast_info _swigc__p_wxPyFileDropTarget[] = { {&_swigt__p_wxPyFileDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37675 static swig_cast_info _swigc__p_wxPyLog[] = { {&_swigt__p_wxPyLog, 0, 0, 0},{0, 0, 0, 0}};
37676 static swig_cast_info _swigc__p_wxPyProcess[] = { {&_swigt__p_wxPyProcess, 0, 0, 0},{0, 0, 0, 0}};
37677 static swig_cast_info _swigc__p_wxPyTextDataObject[] = { {&_swigt__p_wxPyTextDataObject, 0, 0, 0},{0, 0, 0, 0}};
37678 static swig_cast_info _swigc__p_wxPyTextDropTarget[] = { {&_swigt__p_wxPyTextDropTarget, 0, 0, 0},{0, 0, 0, 0}};
37679 static swig_cast_info _swigc__p_wxPyTimer[] = { {&_swigt__p_wxPyTimer, 0, 0, 0},{0, 0, 0, 0}};
37680 static swig_cast_info _swigc__p_wxPyTipProvider[] = { {&_swigt__p_wxPyTipProvider, 0, 0, 0},{0, 0, 0, 0}};
37681 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
37682 static swig_cast_info _swigc__p_wxSingleInstanceChecker[] = { {&_swigt__p_wxSingleInstanceChecker, 0, 0, 0},{0, 0, 0, 0}};
37683 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
37684 static swig_cast_info _swigc__p_wxSound[] = { {&_swigt__p_wxSound, 0, 0, 0},{0, 0, 0, 0}};
37685 static swig_cast_info _swigc__p_wxStandardPaths[] = { {&_swigt__p_wxStandardPaths, 0, 0, 0},{0, 0, 0, 0}};
37686 static swig_cast_info _swigc__p_wxStopWatch[] = { {&_swigt__p_wxStopWatch, 0, 0, 0},{0, 0, 0, 0}};
37687 static swig_cast_info _swigc__p_wxString[] = { {&_swigt__p_wxString, 0, 0, 0},{0, 0, 0, 0}};
37688 static swig_cast_info _swigc__p_wxSystemOptions[] = { {&_swigt__p_wxSystemOptions, 0, 0, 0},{0, 0, 0, 0}};
37689 static swig_cast_info _swigc__p_wxSystemSettings[] = { {&_swigt__p_wxSystemSettings, 0, 0, 0},{0, 0, 0, 0}};
37690 static swig_cast_info _swigc__p_wxTextCtrl[] = { {&_swigt__p_wxTextCtrl, 0, 0, 0},{0, 0, 0, 0}};
37691 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}};
37692 static swig_cast_info _swigc__p_wxTimeSpan[] = { {&_swigt__p_wxTimeSpan, 0, 0, 0},{0, 0, 0, 0}};
37693 static swig_cast_info _swigc__p_wxTimer[] = { {&_swigt__p_wxTimer, 0, 0, 0},{0, 0, 0, 0}};
37694 static swig_cast_info _swigc__p_wxTimerEvent[] = { {&_swigt__p_wxTimerEvent, 0, 0, 0},{0, 0, 0, 0}};
37695 static swig_cast_info _swigc__p_wxTimerRunner[] = { {&_swigt__p_wxTimerRunner, 0, 0, 0},{0, 0, 0, 0}};
37696 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}};
37697 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
37698 static swig_cast_info _swigc__p_wxURLDataObject[] = { {&_swigt__p_wxURLDataObject, 0, 0, 0},{0, 0, 0, 0}};
37699 static swig_cast_info _swigc__p_wxVideoMode[] = { {&_swigt__p_wxVideoMode, 0, 0, 0},{0, 0, 0, 0}};
37700 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}};
37701 static swig_cast_info _swigc__p_wxWindowDisabler[] = { {&_swigt__p_wxWindowDisabler, 0, 0, 0},{0, 0, 0, 0}};
37702
37703 static swig_cast_info *swig_cast_initial[] = {
37704 _swigc__p_char,
37705 _swigc__p_form_ops_t,
37706 _swigc__p_int,
37707 _swigc__p_unsigned_char,
37708 _swigc__p_unsigned_int,
37709 _swigc__p_unsigned_long,
37710 _swigc__p_void,
37711 _swigc__p_wxANIHandler,
37712 _swigc__p_wxAcceleratorTable,
37713 _swigc__p_wxActivateEvent,
37714 _swigc__p_wxArrayString,
37715 _swigc__p_wxBMPHandler,
37716 _swigc__p_wxBitmap,
37717 _swigc__p_wxBitmapDataObject,
37718 _swigc__p_wxBoxSizer,
37719 _swigc__p_wxBusyCursor,
37720 _swigc__p_wxBusyInfo,
37721 _swigc__p_wxCURHandler,
37722 _swigc__p_wxCaret,
37723 _swigc__p_wxChar,
37724 _swigc__p_wxChildFocusEvent,
37725 _swigc__p_wxClipboard,
37726 _swigc__p_wxClipboardLocker,
37727 _swigc__p_wxCloseEvent,
37728 _swigc__p_wxColour,
37729 _swigc__p_wxCommandEvent,
37730 _swigc__p_wxConfig,
37731 _swigc__p_wxConfigBase,
37732 _swigc__p_wxConfigPathChanger,
37733 _swigc__p_wxContextMenuEvent,
37734 _swigc__p_wxControl,
37735 _swigc__p_wxControlWithItems,
37736 _swigc__p_wxCursor,
37737 _swigc__p_wxCustomDataObject,
37738 _swigc__p_wxDC,
37739 _swigc__p_wxDataFormat,
37740 _swigc__p_wxDataObject,
37741 _swigc__p_wxDataObjectComposite,
37742 _swigc__p_wxDataObjectSimple,
37743 _swigc__p_wxDateEvent,
37744 _swigc__p_wxDateSpan,
37745 _swigc__p_wxDateTime,
37746 _swigc__p_wxDateTime__TimeZone,
37747 _swigc__p_wxDisplay,
37748 _swigc__p_wxDisplayChangedEvent,
37749 _swigc__p_wxDropFilesEvent,
37750 _swigc__p_wxDuplexMode,
37751 _swigc__p_wxEraseEvent,
37752 _swigc__p_wxEvent,
37753 _swigc__p_wxEvtHandler,
37754 _swigc__p_wxFSFile,
37755 _swigc__p_wxFileConfig,
37756 _swigc__p_wxFileDataObject,
37757 _swigc__p_wxFileHistory,
37758 _swigc__p_wxFileSystem,
37759 _swigc__p_wxFileType,
37760 _swigc__p_wxFileTypeInfo,
37761 _swigc__p_wxFlexGridSizer,
37762 _swigc__p_wxFocusEvent,
37763 _swigc__p_wxFont,
37764 _swigc__p_wxFrame,
37765 _swigc__p_wxGBSizerItem,
37766 _swigc__p_wxGIFHandler,
37767 _swigc__p_wxGridBagSizer,
37768 _swigc__p_wxGridSizer,
37769 _swigc__p_wxICOHandler,
37770 _swigc__p_wxIcon,
37771 _swigc__p_wxIconizeEvent,
37772 _swigc__p_wxIdleEvent,
37773 _swigc__p_wxImage,
37774 _swigc__p_wxImageHandler,
37775 _swigc__p_wxIndividualLayoutConstraint,
37776 _swigc__p_wxInitDialogEvent,
37777 _swigc__p_wxJPEGHandler,
37778 _swigc__p_wxJoystick,
37779 _swigc__p_wxJoystickEvent,
37780 _swigc__p_wxKeyEvent,
37781 _swigc__p_wxKillError,
37782 _swigc__p_wxLayoutConstraints,
37783 _swigc__p_wxLog,
37784 _swigc__p_wxLogBuffer,
37785 _swigc__p_wxLogChain,
37786 _swigc__p_wxLogGui,
37787 _swigc__p_wxLogNull,
37788 _swigc__p_wxLogStderr,
37789 _swigc__p_wxLogTextCtrl,
37790 _swigc__p_wxLogWindow,
37791 _swigc__p_wxMaximizeEvent,
37792 _swigc__p_wxMemorySize,
37793 _swigc__p_wxMenu,
37794 _swigc__p_wxMenuBar,
37795 _swigc__p_wxMenuEvent,
37796 _swigc__p_wxMenuItem,
37797 _swigc__p_wxMetafile,
37798 _swigc__p_wxMetafileDataObject,
37799 _swigc__p_wxMimeTypesManager,
37800 _swigc__p_wxMouseCaptureChangedEvent,
37801 _swigc__p_wxMouseEvent,
37802 _swigc__p_wxMouseState,
37803 _swigc__p_wxMoveEvent,
37804 _swigc__p_wxMutexGuiLocker,
37805 _swigc__p_wxNavigationKeyEvent,
37806 _swigc__p_wxNcPaintEvent,
37807 _swigc__p_wxNotifyEvent,
37808 _swigc__p_wxObject,
37809 _swigc__p_wxOutputStream,
37810 _swigc__p_wxPCXHandler,
37811 _swigc__p_wxPNGHandler,
37812 _swigc__p_wxPNMHandler,
37813 _swigc__p_wxPaintEvent,
37814 _swigc__p_wxPaletteChangedEvent,
37815 _swigc__p_wxPaperSize,
37816 _swigc__p_wxPoint,
37817 _swigc__p_wxProcessEvent,
37818 _swigc__p_wxPyApp,
37819 _swigc__p_wxPyArtProvider,
37820 _swigc__p_wxPyBitmapDataObject,
37821 _swigc__p_wxPyCommandEvent,
37822 _swigc__p_wxPyDataObjectSimple,
37823 _swigc__p_wxPyDropSource,
37824 _swigc__p_wxPyDropTarget,
37825 _swigc__p_wxPyEvent,
37826 _swigc__p_wxPyFileDropTarget,
37827 _swigc__p_wxPyImageHandler,
37828 _swigc__p_wxPyLog,
37829 _swigc__p_wxPyProcess,
37830 _swigc__p_wxPySizer,
37831 _swigc__p_wxPyTextDataObject,
37832 _swigc__p_wxPyTextDropTarget,
37833 _swigc__p_wxPyTimer,
37834 _swigc__p_wxPyTipProvider,
37835 _swigc__p_wxPyValidator,
37836 _swigc__p_wxQueryNewPaletteEvent,
37837 _swigc__p_wxRect,
37838 _swigc__p_wxScrollEvent,
37839 _swigc__p_wxScrollWinEvent,
37840 _swigc__p_wxSetCursorEvent,
37841 _swigc__p_wxShowEvent,
37842 _swigc__p_wxSingleInstanceChecker,
37843 _swigc__p_wxSize,
37844 _swigc__p_wxSizeEvent,
37845 _swigc__p_wxSizer,
37846 _swigc__p_wxSizerItem,
37847 _swigc__p_wxSound,
37848 _swigc__p_wxStandardPaths,
37849 _swigc__p_wxStaticBoxSizer,
37850 _swigc__p_wxStdDialogButtonSizer,
37851 _swigc__p_wxStopWatch,
37852 _swigc__p_wxString,
37853 _swigc__p_wxSysColourChangedEvent,
37854 _swigc__p_wxSystemOptions,
37855 _swigc__p_wxSystemSettings,
37856 _swigc__p_wxTIFFHandler,
37857 _swigc__p_wxTextCtrl,
37858 _swigc__p_wxTextDataObject,
37859 _swigc__p_wxTimeSpan,
37860 _swigc__p_wxTimer,
37861 _swigc__p_wxTimerEvent,
37862 _swigc__p_wxTimerRunner,
37863 _swigc__p_wxTipProvider,
37864 _swigc__p_wxToolTip,
37865 _swigc__p_wxURLDataObject,
37866 _swigc__p_wxUpdateUIEvent,
37867 _swigc__p_wxValidator,
37868 _swigc__p_wxVideoMode,
37869 _swigc__p_wxWindow,
37870 _swigc__p_wxWindowCreateEvent,
37871 _swigc__p_wxWindowDestroyEvent,
37872 _swigc__p_wxWindowDisabler,
37873 _swigc__p_wxXPMHandler,
37874 };
37875
37876
37877 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
37878
37879 static swig_const_info swig_const_table[] = {
37880 {0, 0, 0, 0.0, 0, 0}};
37881
37882 #ifdef __cplusplus
37883 }
37884 #endif
37885 /* -----------------------------------------------------------------------------
37886 * Type initialization:
37887 * This problem is tough by the requirement that no dynamic
37888 * memory is used. Also, since swig_type_info structures store pointers to
37889 * swig_cast_info structures and swig_cast_info structures store pointers back
37890 * to swig_type_info structures, we need some lookup code at initialization.
37891 * The idea is that swig generates all the structures that are needed.
37892 * The runtime then collects these partially filled structures.
37893 * The SWIG_InitializeModule function takes these initial arrays out of
37894 * swig_module, and does all the lookup, filling in the swig_module.types
37895 * array with the correct data and linking the correct swig_cast_info
37896 * structures together.
37897 *
37898 * The generated swig_type_info structures are assigned staticly to an initial
37899 * array. We just loop though that array, and handle each type individually.
37900 * First we lookup if this type has been already loaded, and if so, use the
37901 * loaded structure instead of the generated one. Then we have to fill in the
37902 * cast linked list. The cast data is initially stored in something like a
37903 * two-dimensional array. Each row corresponds to a type (there are the same
37904 * number of rows as there are in the swig_type_initial array). Each entry in
37905 * a column is one of the swig_cast_info structures for that type.
37906 * The cast_initial array is actually an array of arrays, because each row has
37907 * a variable number of columns. So to actually build the cast linked list,
37908 * we find the array of casts associated with the type, and loop through it
37909 * adding the casts to the list. The one last trick we need to do is making
37910 * sure the type pointer in the swig_cast_info struct is correct.
37911 *
37912 * First off, we lookup the cast->type name to see if it is already loaded.
37913 * There are three cases to handle:
37914 * 1) If the cast->type has already been loaded AND the type we are adding
37915 * casting info to has not been loaded (it is in this module), THEN we
37916 * replace the cast->type pointer with the type pointer that has already
37917 * been loaded.
37918 * 2) If BOTH types (the one we are adding casting info to, and the
37919 * cast->type) are loaded, THEN the cast info has already been loaded by
37920 * the previous module so we just ignore it.
37921 * 3) Finally, if cast->type has not already been loaded, then we add that
37922 * swig_cast_info to the linked list (because the cast->type) pointer will
37923 * be correct.
37924 * ----------------------------------------------------------------------------- */
37925
37926 #ifdef __cplusplus
37927 extern "C" {
37928 #if 0
37929 } /* c-mode */
37930 #endif
37931 #endif
37932
37933 #if 0
37934 #define SWIGRUNTIME_DEBUG
37935 #endif
37936
37937 SWIGRUNTIME void
37938 SWIG_InitializeModule(void *clientdata) {
37939 size_t i;
37940 swig_module_info *module_head;
37941 static int init_run = 0;
37942
37943 clientdata = clientdata;
37944
37945 if (init_run) return;
37946 init_run = 1;
37947
37948 /* Initialize the swig_module */
37949 swig_module.type_initial = swig_type_initial;
37950 swig_module.cast_initial = swig_cast_initial;
37951
37952 /* Try and load any already created modules */
37953 module_head = SWIG_GetModule(clientdata);
37954 if (module_head) {
37955 swig_module.next = module_head->next;
37956 module_head->next = &swig_module;
37957 } else {
37958 /* This is the first module loaded */
37959 swig_module.next = &swig_module;
37960 SWIG_SetModule(clientdata, &swig_module);
37961 }
37962
37963 /* Now work on filling in swig_module.types */
37964 #ifdef SWIGRUNTIME_DEBUG
37965 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
37966 #endif
37967 for (i = 0; i < swig_module.size; ++i) {
37968 swig_type_info *type = 0;
37969 swig_type_info *ret;
37970 swig_cast_info *cast;
37971
37972 #ifdef SWIGRUNTIME_DEBUG
37973 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
37974 #endif
37975
37976 /* if there is another module already loaded */
37977 if (swig_module.next != &swig_module) {
37978 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
37979 }
37980 if (type) {
37981 /* Overwrite clientdata field */
37982 #ifdef SWIGRUNTIME_DEBUG
37983 printf("SWIG_InitializeModule: found type %s\n", type->name);
37984 #endif
37985 if (swig_module.type_initial[i]->clientdata) {
37986 type->clientdata = swig_module.type_initial[i]->clientdata;
37987 #ifdef SWIGRUNTIME_DEBUG
37988 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
37989 #endif
37990 }
37991 } else {
37992 type = swig_module.type_initial[i];
37993 }
37994
37995 /* Insert casting types */
37996 cast = swig_module.cast_initial[i];
37997 while (cast->type) {
37998 /* Don't need to add information already in the list */
37999 ret = 0;
38000 #ifdef SWIGRUNTIME_DEBUG
38001 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
38002 #endif
38003 if (swig_module.next != &swig_module) {
38004 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
38005 #ifdef SWIGRUNTIME_DEBUG
38006 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
38007 #endif
38008 }
38009 if (ret) {
38010 if (type == swig_module.type_initial[i]) {
38011 #ifdef SWIGRUNTIME_DEBUG
38012 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
38013 #endif
38014 cast->type = ret;
38015 ret = 0;
38016 } else {
38017 /* Check for casting already in the list */
38018 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
38019 #ifdef SWIGRUNTIME_DEBUG
38020 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
38021 #endif
38022 if (!ocast) ret = 0;
38023 }
38024 }
38025
38026 if (!ret) {
38027 #ifdef SWIGRUNTIME_DEBUG
38028 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
38029 #endif
38030 if (type->cast) {
38031 type->cast->prev = cast;
38032 cast->next = type->cast;
38033 }
38034 type->cast = cast;
38035 }
38036 cast++;
38037 }
38038 /* Set entry in modules->types array equal to the type */
38039 swig_module.types[i] = type;
38040 }
38041 swig_module.types[i] = 0;
38042
38043 #ifdef SWIGRUNTIME_DEBUG
38044 printf("**** SWIG_InitializeModule: Cast List ******\n");
38045 for (i = 0; i < swig_module.size; ++i) {
38046 int j = 0;
38047 swig_cast_info *cast = swig_module.cast_initial[i];
38048 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
38049 while (cast->type) {
38050 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
38051 cast++;
38052 ++j;
38053 }
38054 printf("---- Total casts: %d\n",j);
38055 }
38056 printf("**** SWIG_InitializeModule: Cast List ******\n");
38057 #endif
38058 }
38059
38060 /* This function will propagate the clientdata field of type to
38061 * any new swig_type_info structures that have been added into the list
38062 * of equivalent types. It is like calling
38063 * SWIG_TypeClientData(type, clientdata) a second time.
38064 */
38065 SWIGRUNTIME void
38066 SWIG_PropagateClientData(void) {
38067 size_t i;
38068 swig_cast_info *equiv;
38069 static int init_run = 0;
38070
38071 if (init_run) return;
38072 init_run = 1;
38073
38074 for (i = 0; i < swig_module.size; i++) {
38075 if (swig_module.types[i]->clientdata) {
38076 equiv = swig_module.types[i]->cast;
38077 while (equiv) {
38078 if (!equiv->converter) {
38079 if (equiv->type && !equiv->type->clientdata)
38080 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
38081 }
38082 equiv = equiv->next;
38083 }
38084 }
38085 }
38086 }
38087
38088 #ifdef __cplusplus
38089 #if 0
38090 {
38091 /* c-mode */
38092 #endif
38093 }
38094 #endif
38095
38096
38097
38098 #ifdef __cplusplus
38099 extern "C" {
38100 #endif
38101
38102 /* Python-specific SWIG API */
38103 #define SWIG_newvarlink() SWIG_Python_newvarlink()
38104 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
38105 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
38106
38107 /* -----------------------------------------------------------------------------
38108 * global variable support code.
38109 * ----------------------------------------------------------------------------- */
38110
38111 typedef struct swig_globalvar {
38112 char *name; /* Name of global variable */
38113 PyObject *(*get_attr)(void); /* Return the current value */
38114 int (*set_attr)(PyObject *); /* Set the value */
38115 struct swig_globalvar *next;
38116 } swig_globalvar;
38117
38118 typedef struct swig_varlinkobject {
38119 PyObject_HEAD
38120 swig_globalvar *vars;
38121 } swig_varlinkobject;
38122
38123 SWIGINTERN PyObject *
38124 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
38125 return PyString_FromString("<Swig global variables>");
38126 }
38127
38128 SWIGINTERN PyObject *
38129 swig_varlink_str(swig_varlinkobject *v) {
38130 PyObject *str = PyString_FromString("(");
38131 swig_globalvar *var;
38132 for (var = v->vars; var; var=var->next) {
38133 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
38134 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
38135 }
38136 PyString_ConcatAndDel(&str,PyString_FromString(")"));
38137 return str;
38138 }
38139
38140 SWIGINTERN int
38141 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
38142 PyObject *str = swig_varlink_str(v);
38143 fprintf(fp,"Swig global variables ");
38144 fprintf(fp,"%s\n", PyString_AsString(str));
38145 Py_DECREF(str);
38146 return 0;
38147 }
38148
38149 SWIGINTERN void
38150 swig_varlink_dealloc(swig_varlinkobject *v) {
38151 swig_globalvar *var = v->vars;
38152 while (var) {
38153 swig_globalvar *n = var->next;
38154 free(var->name);
38155 free(var);
38156 var = n;
38157 }
38158 }
38159
38160 SWIGINTERN PyObject *
38161 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
38162 PyObject *res = NULL;
38163 swig_globalvar *var = v->vars;
38164 while (var) {
38165 if (strcmp(var->name,n) == 0) {
38166 res = (*var->get_attr)();
38167 break;
38168 }
38169 var = var->next;
38170 }
38171 if (res == NULL && !PyErr_Occurred()) {
38172 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38173 }
38174 return res;
38175 }
38176
38177 SWIGINTERN int
38178 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
38179 int res = 1;
38180 swig_globalvar *var = v->vars;
38181 while (var) {
38182 if (strcmp(var->name,n) == 0) {
38183 res = (*var->set_attr)(p);
38184 break;
38185 }
38186 var = var->next;
38187 }
38188 if (res == 1 && !PyErr_Occurred()) {
38189 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
38190 }
38191 return res;
38192 }
38193
38194 SWIGINTERN PyTypeObject*
38195 swig_varlink_type(void) {
38196 static char varlink__doc__[] = "Swig var link object";
38197 static PyTypeObject varlink_type;
38198 static int type_init = 0;
38199 if (!type_init) {
38200 const PyTypeObject tmp
38201 = {
38202 PyObject_HEAD_INIT(NULL)
38203 0, /* Number of items in variable part (ob_size) */
38204 (char *)"swigvarlink", /* Type name (tp_name) */
38205 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
38206 0, /* Itemsize (tp_itemsize) */
38207 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
38208 (printfunc) swig_varlink_print, /* Print (tp_print) */
38209 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
38210 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
38211 0, /* tp_compare */
38212 (reprfunc) swig_varlink_repr, /* tp_repr */
38213 0, /* tp_as_number */
38214 0, /* tp_as_sequence */
38215 0, /* tp_as_mapping */
38216 0, /* tp_hash */
38217 0, /* tp_call */
38218 (reprfunc)swig_varlink_str, /* tp_str */
38219 0, /* tp_getattro */
38220 0, /* tp_setattro */
38221 0, /* tp_as_buffer */
38222 0, /* tp_flags */
38223 varlink__doc__, /* tp_doc */
38224 0, /* tp_traverse */
38225 0, /* tp_clear */
38226 0, /* tp_richcompare */
38227 0, /* tp_weaklistoffset */
38228 #if PY_VERSION_HEX >= 0x02020000
38229 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
38230 #endif
38231 #if PY_VERSION_HEX >= 0x02030000
38232 0, /* tp_del */
38233 #endif
38234 #ifdef COUNT_ALLOCS
38235 0,0,0,0 /* tp_alloc -> tp_next */
38236 #endif
38237 };
38238 varlink_type = tmp;
38239 varlink_type.ob_type = &PyType_Type;
38240 type_init = 1;
38241 }
38242 return &varlink_type;
38243 }
38244
38245 /* Create a variable linking object for use later */
38246 SWIGINTERN PyObject *
38247 SWIG_Python_newvarlink(void) {
38248 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
38249 if (result) {
38250 result->vars = 0;
38251 }
38252 return ((PyObject*) result);
38253 }
38254
38255 SWIGINTERN void
38256 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
38257 swig_varlinkobject *v = (swig_varlinkobject *) p;
38258 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
38259 if (gv) {
38260 size_t size = strlen(name)+1;
38261 gv->name = (char *)malloc(size);
38262 if (gv->name) {
38263 strncpy(gv->name,name,size);
38264 gv->get_attr = get_attr;
38265 gv->set_attr = set_attr;
38266 gv->next = v->vars;
38267 }
38268 }
38269 v->vars = gv;
38270 }
38271
38272 SWIGINTERN PyObject *
38273 SWIG_globals() {
38274 static PyObject *_SWIG_globals = 0;
38275 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
38276 return _SWIG_globals;
38277 }
38278
38279 /* -----------------------------------------------------------------------------
38280 * constants/methods manipulation
38281 * ----------------------------------------------------------------------------- */
38282
38283 /* Install Constants */
38284 SWIGINTERN void
38285 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
38286 PyObject *obj = 0;
38287 size_t i;
38288 for (i = 0; constants[i].type; ++i) {
38289 switch(constants[i].type) {
38290 case SWIG_PY_POINTER:
38291 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
38292 break;
38293 case SWIG_PY_BINARY:
38294 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
38295 break;
38296 default:
38297 obj = 0;
38298 break;
38299 }
38300 if (obj) {
38301 PyDict_SetItemString(d, constants[i].name, obj);
38302 Py_DECREF(obj);
38303 }
38304 }
38305 }
38306
38307 /* -----------------------------------------------------------------------------*/
38308 /* Fix SwigMethods to carry the callback ptrs when needed */
38309 /* -----------------------------------------------------------------------------*/
38310
38311 SWIGINTERN void
38312 SWIG_Python_FixMethods(PyMethodDef *methods,
38313 swig_const_info *const_table,
38314 swig_type_info **types,
38315 swig_type_info **types_initial) {
38316 size_t i;
38317 for (i = 0; methods[i].ml_name; ++i) {
38318 char *c = methods[i].ml_doc;
38319 if (c && (c = strstr(c, "swig_ptr: "))) {
38320 int j;
38321 swig_const_info *ci = 0;
38322 char *name = c + 10;
38323 for (j = 0; const_table[j].type; ++j) {
38324 if (strncmp(const_table[j].name, name,
38325 strlen(const_table[j].name)) == 0) {
38326 ci = &(const_table[j]);
38327 break;
38328 }
38329 }
38330 if (ci) {
38331 size_t shift = (ci->ptype) - types;
38332 swig_type_info *ty = types_initial[shift];
38333 size_t ldoc = (c - methods[i].ml_doc);
38334 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
38335 char *ndoc = (char*)malloc(ldoc + lptr + 10);
38336 if (ndoc) {
38337 char *buff = ndoc;
38338 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
38339 if (ptr) {
38340 strncpy(buff, methods[i].ml_doc, ldoc);
38341 buff += ldoc;
38342 strncpy(buff, "swig_ptr: ", 10);
38343 buff += 10;
38344 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
38345 methods[i].ml_doc = ndoc;
38346 }
38347 }
38348 }
38349 }
38350 }
38351 }
38352
38353 #ifdef __cplusplus
38354 }
38355 #endif
38356
38357 /* -----------------------------------------------------------------------------*
38358 * Partial Init method
38359 * -----------------------------------------------------------------------------*/
38360
38361 #ifdef __cplusplus
38362 extern "C"
38363 #endif
38364 SWIGEXPORT void SWIG_init(void) {
38365 PyObject *m, *d;
38366
38367 /* Fix SwigMethods to carry the callback ptrs when needed */
38368 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
38369
38370 m = Py_InitModule((char *) SWIG_name, SwigMethods);
38371 d = PyModule_GetDict(m);
38372
38373 SWIG_InitializeModule(0);
38374 SWIG_InstallConstants(d,swig_const_table);
38375
38376
38377 SWIG_Python_SetConstant(d, "SYS_OEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_OEM_FIXED_FONT)));
38378 SWIG_Python_SetConstant(d, "SYS_ANSI_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_FIXED_FONT)));
38379 SWIG_Python_SetConstant(d, "SYS_ANSI_VAR_FONT",SWIG_From_int(static_cast< int >(wxSYS_ANSI_VAR_FONT)));
38380 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FONT)));
38381 SWIG_Python_SetConstant(d, "SYS_DEVICE_DEFAULT_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEVICE_DEFAULT_FONT)));
38382 SWIG_Python_SetConstant(d, "SYS_DEFAULT_PALETTE",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_PALETTE)));
38383 SWIG_Python_SetConstant(d, "SYS_SYSTEM_FIXED_FONT",SWIG_From_int(static_cast< int >(wxSYS_SYSTEM_FIXED_FONT)));
38384 SWIG_Python_SetConstant(d, "SYS_DEFAULT_GUI_FONT",SWIG_From_int(static_cast< int >(wxSYS_DEFAULT_GUI_FONT)));
38385 SWIG_Python_SetConstant(d, "SYS_ICONTITLE_FONT",SWIG_From_int(static_cast< int >(wxSYS_ICONTITLE_FONT)));
38386 SWIG_Python_SetConstant(d, "SYS_COLOUR_SCROLLBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_SCROLLBAR)));
38387 SWIG_Python_SetConstant(d, "SYS_COLOUR_BACKGROUND",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BACKGROUND)));
38388 SWIG_Python_SetConstant(d, "SYS_COLOUR_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_DESKTOP)));
38389 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVECAPTION)));
38390 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTION)));
38391 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENU",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENU)));
38392 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOW)));
38393 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWFRAME",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWFRAME)));
38394 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUTEXT)));
38395 SWIG_Python_SetConstant(d, "SYS_COLOUR_WINDOWTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_WINDOWTEXT)));
38396 SWIG_Python_SetConstant(d, "SYS_COLOUR_CAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_CAPTIONTEXT)));
38397 SWIG_Python_SetConstant(d, "SYS_COLOUR_ACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_ACTIVEBORDER)));
38398 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVEBORDER",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVEBORDER)));
38399 SWIG_Python_SetConstant(d, "SYS_COLOUR_APPWORKSPACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_APPWORKSPACE)));
38400 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHT)));
38401 SWIG_Python_SetConstant(d, "SYS_COLOUR_HIGHLIGHTTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HIGHLIGHTTEXT)));
38402 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNFACE)));
38403 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DFACE",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DFACE)));
38404 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNSHADOW)));
38405 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DSHADOW)));
38406 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRAYTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRAYTEXT)));
38407 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNTEXT)));
38408 SWIG_Python_SetConstant(d, "SYS_COLOUR_INACTIVECAPTIONTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
38409 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHIGHLIGHT)));
38410 SWIG_Python_SetConstant(d, "SYS_COLOUR_BTNHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_BTNHILIGHT)));
38411 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHIGHLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHIGHLIGHT)));
38412 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DHILIGHT)));
38413 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DDKSHADOW",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DDKSHADOW)));
38414 SWIG_Python_SetConstant(d, "SYS_COLOUR_3DLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_3DLIGHT)));
38415 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOTEXT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOTEXT)));
38416 SWIG_Python_SetConstant(d, "SYS_COLOUR_INFOBK",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_INFOBK)));
38417 SWIG_Python_SetConstant(d, "SYS_COLOUR_LISTBOX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_LISTBOX)));
38418 SWIG_Python_SetConstant(d, "SYS_COLOUR_HOTLIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_HOTLIGHT)));
38419 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
38420 SWIG_Python_SetConstant(d, "SYS_COLOUR_GRADIENTINACTIVECAPTION",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
38421 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUHILIGHT",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUHILIGHT)));
38422 SWIG_Python_SetConstant(d, "SYS_COLOUR_MENUBAR",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MENUBAR)));
38423 SWIG_Python_SetConstant(d, "SYS_COLOUR_MAX",SWIG_From_int(static_cast< int >(wxSYS_COLOUR_MAX)));
38424 SWIG_Python_SetConstant(d, "SYS_MOUSE_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_MOUSE_BUTTONS)));
38425 SWIG_Python_SetConstant(d, "SYS_BORDER_X",SWIG_From_int(static_cast< int >(wxSYS_BORDER_X)));
38426 SWIG_Python_SetConstant(d, "SYS_BORDER_Y",SWIG_From_int(static_cast< int >(wxSYS_BORDER_Y)));
38427 SWIG_Python_SetConstant(d, "SYS_CURSOR_X",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_X)));
38428 SWIG_Python_SetConstant(d, "SYS_CURSOR_Y",SWIG_From_int(static_cast< int >(wxSYS_CURSOR_Y)));
38429 SWIG_Python_SetConstant(d, "SYS_DCLICK_X",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_X)));
38430 SWIG_Python_SetConstant(d, "SYS_DCLICK_Y",SWIG_From_int(static_cast< int >(wxSYS_DCLICK_Y)));
38431 SWIG_Python_SetConstant(d, "SYS_DRAG_X",SWIG_From_int(static_cast< int >(wxSYS_DRAG_X)));
38432 SWIG_Python_SetConstant(d, "SYS_DRAG_Y",SWIG_From_int(static_cast< int >(wxSYS_DRAG_Y)));
38433 SWIG_Python_SetConstant(d, "SYS_EDGE_X",SWIG_From_int(static_cast< int >(wxSYS_EDGE_X)));
38434 SWIG_Python_SetConstant(d, "SYS_EDGE_Y",SWIG_From_int(static_cast< int >(wxSYS_EDGE_Y)));
38435 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_X)));
38436 SWIG_Python_SetConstant(d, "SYS_HSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_ARROW_Y)));
38437 SWIG_Python_SetConstant(d, "SYS_HTHUMB_X",SWIG_From_int(static_cast< int >(wxSYS_HTHUMB_X)));
38438 SWIG_Python_SetConstant(d, "SYS_ICON_X",SWIG_From_int(static_cast< int >(wxSYS_ICON_X)));
38439 SWIG_Python_SetConstant(d, "SYS_ICON_Y",SWIG_From_int(static_cast< int >(wxSYS_ICON_Y)));
38440 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_X",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_X)));
38441 SWIG_Python_SetConstant(d, "SYS_ICONSPACING_Y",SWIG_From_int(static_cast< int >(wxSYS_ICONSPACING_Y)));
38442 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_X",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_X)));
38443 SWIG_Python_SetConstant(d, "SYS_WINDOWMIN_Y",SWIG_From_int(static_cast< int >(wxSYS_WINDOWMIN_Y)));
38444 SWIG_Python_SetConstant(d, "SYS_SCREEN_X",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_X)));
38445 SWIG_Python_SetConstant(d, "SYS_SCREEN_Y",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_Y)));
38446 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_X",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_X)));
38447 SWIG_Python_SetConstant(d, "SYS_FRAMESIZE_Y",SWIG_From_int(static_cast< int >(wxSYS_FRAMESIZE_Y)));
38448 SWIG_Python_SetConstant(d, "SYS_SMALLICON_X",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_X)));
38449 SWIG_Python_SetConstant(d, "SYS_SMALLICON_Y",SWIG_From_int(static_cast< int >(wxSYS_SMALLICON_Y)));
38450 SWIG_Python_SetConstant(d, "SYS_HSCROLL_Y",SWIG_From_int(static_cast< int >(wxSYS_HSCROLL_Y)));
38451 SWIG_Python_SetConstant(d, "SYS_VSCROLL_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_X)));
38452 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_X",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_X)));
38453 SWIG_Python_SetConstant(d, "SYS_VSCROLL_ARROW_Y",SWIG_From_int(static_cast< int >(wxSYS_VSCROLL_ARROW_Y)));
38454 SWIG_Python_SetConstant(d, "SYS_VTHUMB_Y",SWIG_From_int(static_cast< int >(wxSYS_VTHUMB_Y)));
38455 SWIG_Python_SetConstant(d, "SYS_CAPTION_Y",SWIG_From_int(static_cast< int >(wxSYS_CAPTION_Y)));
38456 SWIG_Python_SetConstant(d, "SYS_MENU_Y",SWIG_From_int(static_cast< int >(wxSYS_MENU_Y)));
38457 SWIG_Python_SetConstant(d, "SYS_NETWORK_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_NETWORK_PRESENT)));
38458 SWIG_Python_SetConstant(d, "SYS_PENWINDOWS_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_PENWINDOWS_PRESENT)));
38459 SWIG_Python_SetConstant(d, "SYS_SHOW_SOUNDS",SWIG_From_int(static_cast< int >(wxSYS_SHOW_SOUNDS)));
38460 SWIG_Python_SetConstant(d, "SYS_SWAP_BUTTONS",SWIG_From_int(static_cast< int >(wxSYS_SWAP_BUTTONS)));
38461 SWIG_Python_SetConstant(d, "SYS_CAN_DRAW_FRAME_DECORATIONS",SWIG_From_int(static_cast< int >(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
38462 SWIG_Python_SetConstant(d, "SYS_CAN_ICONIZE_FRAME",SWIG_From_int(static_cast< int >(wxSYS_CAN_ICONIZE_FRAME)));
38463 SWIG_Python_SetConstant(d, "SYS_TABLET_PRESENT",SWIG_From_int(static_cast< int >(wxSYS_TABLET_PRESENT)));
38464 SWIG_Python_SetConstant(d, "SYS_SCREEN_NONE",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_NONE)));
38465 SWIG_Python_SetConstant(d, "SYS_SCREEN_TINY",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_TINY)));
38466 SWIG_Python_SetConstant(d, "SYS_SCREEN_PDA",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_PDA)));
38467 SWIG_Python_SetConstant(d, "SYS_SCREEN_SMALL",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_SMALL)));
38468 SWIG_Python_SetConstant(d, "SYS_SCREEN_DESKTOP",SWIG_From_int(static_cast< int >(wxSYS_SCREEN_DESKTOP)));
38469 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
38470 SWIG_addvarlink(SWIG_globals(),(char*)"WINDOW_DEFAULT_VARIANT",WINDOW_DEFAULT_VARIANT_get, WINDOW_DEFAULT_VARIANT_set);
38471 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorPromptStr",FileSelectorPromptStr_get, FileSelectorPromptStr_set);
38472 SWIG_addvarlink(SWIG_globals(),(char*)"FileSelectorDefaultWildcardStr",FileSelectorDefaultWildcardStr_get, FileSelectorDefaultWildcardStr_set);
38473 SWIG_addvarlink(SWIG_globals(),(char*)"DirSelectorPromptStr",DirSelectorPromptStr_get, DirSelectorPromptStr_set);
38474 SWIG_Python_SetConstant(d, "SHUTDOWN_POWEROFF",SWIG_From_int(static_cast< int >(wxSHUTDOWN_POWEROFF)));
38475 SWIG_Python_SetConstant(d, "SHUTDOWN_REBOOT",SWIG_From_int(static_cast< int >(wxSHUTDOWN_REBOOT)));
38476 SWIG_Python_SetConstant(d, "TIMER_CONTINUOUS",SWIG_From_int(static_cast< int >(wxTIMER_CONTINUOUS)));
38477 SWIG_Python_SetConstant(d, "TIMER_ONE_SHOT",SWIG_From_int(static_cast< int >(wxTIMER_ONE_SHOT)));
38478 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
38479
38480 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
38481
38482 SWIG_Python_SetConstant(d, "LOG_FatalError",SWIG_From_int(static_cast< int >(wxLOG_FatalError)));
38483 SWIG_Python_SetConstant(d, "LOG_Error",SWIG_From_int(static_cast< int >(wxLOG_Error)));
38484 SWIG_Python_SetConstant(d, "LOG_Warning",SWIG_From_int(static_cast< int >(wxLOG_Warning)));
38485 SWIG_Python_SetConstant(d, "LOG_Message",SWIG_From_int(static_cast< int >(wxLOG_Message)));
38486 SWIG_Python_SetConstant(d, "LOG_Status",SWIG_From_int(static_cast< int >(wxLOG_Status)));
38487 SWIG_Python_SetConstant(d, "LOG_Info",SWIG_From_int(static_cast< int >(wxLOG_Info)));
38488 SWIG_Python_SetConstant(d, "LOG_Debug",SWIG_From_int(static_cast< int >(wxLOG_Debug)));
38489 SWIG_Python_SetConstant(d, "LOG_Trace",SWIG_From_int(static_cast< int >(wxLOG_Trace)));
38490 SWIG_Python_SetConstant(d, "LOG_Progress",SWIG_From_int(static_cast< int >(wxLOG_Progress)));
38491 SWIG_Python_SetConstant(d, "LOG_User",SWIG_From_int(static_cast< int >(wxLOG_User)));
38492 SWIG_Python_SetConstant(d, "LOG_Max",SWIG_From_int(static_cast< int >(wxLOG_Max)));
38493 SWIG_Python_SetConstant(d, "TRACE_MemAlloc",SWIG_FromCharPtr("memalloc"));
38494 SWIG_Python_SetConstant(d, "TRACE_Messages",SWIG_FromCharPtr("messages"));
38495 SWIG_Python_SetConstant(d, "TRACE_ResAlloc",SWIG_FromCharPtr("resalloc"));
38496 SWIG_Python_SetConstant(d, "TRACE_RefCount",SWIG_FromCharPtr("refcount"));
38497 SWIG_Python_SetConstant(d, "TRACE_OleCalls",SWIG_FromCharPtr("ole"));
38498 SWIG_Python_SetConstant(d, "TraceMemAlloc",SWIG_From_int(static_cast< int >(0x0001)));
38499 SWIG_Python_SetConstant(d, "TraceMessages",SWIG_From_int(static_cast< int >(0x0002)));
38500 SWIG_Python_SetConstant(d, "TraceResAlloc",SWIG_From_int(static_cast< int >(0x0004)));
38501 SWIG_Python_SetConstant(d, "TraceRefCount",SWIG_From_int(static_cast< int >(0x0008)));
38502 SWIG_Python_SetConstant(d, "TraceOleCalls",SWIG_From_int(static_cast< int >(0x0100)));
38503 SWIG_Python_SetConstant(d, "PROCESS_DEFAULT",SWIG_From_int(static_cast< int >(wxPROCESS_DEFAULT)));
38504 SWIG_Python_SetConstant(d, "PROCESS_REDIRECT",SWIG_From_int(static_cast< int >(wxPROCESS_REDIRECT)));
38505 SWIG_Python_SetConstant(d, "KILL_OK",SWIG_From_int(static_cast< int >(wxKILL_OK)));
38506 SWIG_Python_SetConstant(d, "KILL_BAD_SIGNAL",SWIG_From_int(static_cast< int >(wxKILL_BAD_SIGNAL)));
38507 SWIG_Python_SetConstant(d, "KILL_ACCESS_DENIED",SWIG_From_int(static_cast< int >(wxKILL_ACCESS_DENIED)));
38508 SWIG_Python_SetConstant(d, "KILL_NO_PROCESS",SWIG_From_int(static_cast< int >(wxKILL_NO_PROCESS)));
38509 SWIG_Python_SetConstant(d, "KILL_ERROR",SWIG_From_int(static_cast< int >(wxKILL_ERROR)));
38510 SWIG_Python_SetConstant(d, "KILL_NOCHILDREN",SWIG_From_int(static_cast< int >(wxKILL_NOCHILDREN)));
38511 SWIG_Python_SetConstant(d, "KILL_CHILDREN",SWIG_From_int(static_cast< int >(wxKILL_CHILDREN)));
38512 SWIG_Python_SetConstant(d, "SIGNONE",SWIG_From_int(static_cast< int >(wxSIGNONE)));
38513 SWIG_Python_SetConstant(d, "SIGHUP",SWIG_From_int(static_cast< int >(wxSIGHUP)));
38514 SWIG_Python_SetConstant(d, "SIGINT",SWIG_From_int(static_cast< int >(wxSIGINT)));
38515 SWIG_Python_SetConstant(d, "SIGQUIT",SWIG_From_int(static_cast< int >(wxSIGQUIT)));
38516 SWIG_Python_SetConstant(d, "SIGILL",SWIG_From_int(static_cast< int >(wxSIGILL)));
38517 SWIG_Python_SetConstant(d, "SIGTRAP",SWIG_From_int(static_cast< int >(wxSIGTRAP)));
38518 SWIG_Python_SetConstant(d, "SIGABRT",SWIG_From_int(static_cast< int >(wxSIGABRT)));
38519 SWIG_Python_SetConstant(d, "SIGIOT",SWIG_From_int(static_cast< int >(wxSIGIOT)));
38520 SWIG_Python_SetConstant(d, "SIGEMT",SWIG_From_int(static_cast< int >(wxSIGEMT)));
38521 SWIG_Python_SetConstant(d, "SIGFPE",SWIG_From_int(static_cast< int >(wxSIGFPE)));
38522 SWIG_Python_SetConstant(d, "SIGKILL",SWIG_From_int(static_cast< int >(wxSIGKILL)));
38523 SWIG_Python_SetConstant(d, "SIGBUS",SWIG_From_int(static_cast< int >(wxSIGBUS)));
38524 SWIG_Python_SetConstant(d, "SIGSEGV",SWIG_From_int(static_cast< int >(wxSIGSEGV)));
38525 SWIG_Python_SetConstant(d, "SIGSYS",SWIG_From_int(static_cast< int >(wxSIGSYS)));
38526 SWIG_Python_SetConstant(d, "SIGPIPE",SWIG_From_int(static_cast< int >(wxSIGPIPE)));
38527 SWIG_Python_SetConstant(d, "SIGALRM",SWIG_From_int(static_cast< int >(wxSIGALRM)));
38528 SWIG_Python_SetConstant(d, "SIGTERM",SWIG_From_int(static_cast< int >(wxSIGTERM)));
38529 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
38530 SWIG_Python_SetConstant(d, "EXEC_ASYNC",SWIG_From_int(static_cast< int >(wxEXEC_ASYNC)));
38531 SWIG_Python_SetConstant(d, "EXEC_SYNC",SWIG_From_int(static_cast< int >(wxEXEC_SYNC)));
38532 SWIG_Python_SetConstant(d, "EXEC_NOHIDE",SWIG_From_int(static_cast< int >(wxEXEC_NOHIDE)));
38533 SWIG_Python_SetConstant(d, "EXEC_MAKE_GROUP_LEADER",SWIG_From_int(static_cast< int >(wxEXEC_MAKE_GROUP_LEADER)));
38534 SWIG_Python_SetConstant(d, "EXEC_NODISABLE",SWIG_From_int(static_cast< int >(wxEXEC_NODISABLE)));
38535
38536 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
38537
38538 SWIG_Python_SetConstant(d, "JOYSTICK1",SWIG_From_int(static_cast< int >(wxJOYSTICK1)));
38539 SWIG_Python_SetConstant(d, "JOYSTICK2",SWIG_From_int(static_cast< int >(wxJOYSTICK2)));
38540 SWIG_Python_SetConstant(d, "JOY_BUTTON_ANY",SWIG_From_int(static_cast< int >(wxJOY_BUTTON_ANY)));
38541 SWIG_Python_SetConstant(d, "JOY_BUTTON1",SWIG_From_int(static_cast< int >(wxJOY_BUTTON1)));
38542 SWIG_Python_SetConstant(d, "JOY_BUTTON2",SWIG_From_int(static_cast< int >(wxJOY_BUTTON2)));
38543 SWIG_Python_SetConstant(d, "JOY_BUTTON3",SWIG_From_int(static_cast< int >(wxJOY_BUTTON3)));
38544 SWIG_Python_SetConstant(d, "JOY_BUTTON4",SWIG_From_int(static_cast< int >(wxJOY_BUTTON4)));
38545 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
38546 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
38547 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
38548 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
38549 SWIG_Python_SetConstant(d, "SOUND_SYNC",SWIG_From_int(static_cast< int >(wxSOUND_SYNC)));
38550 SWIG_Python_SetConstant(d, "SOUND_ASYNC",SWIG_From_int(static_cast< int >(wxSOUND_ASYNC)));
38551 SWIG_Python_SetConstant(d, "SOUND_LOOP",SWIG_From_int(static_cast< int >(wxSOUND_LOOP)));
38552 SWIG_Python_SetConstant(d, "MAILCAP_STANDARD",SWIG_From_int(static_cast< int >(wxMAILCAP_STANDARD)));
38553 SWIG_Python_SetConstant(d, "MAILCAP_NETSCAPE",SWIG_From_int(static_cast< int >(wxMAILCAP_NETSCAPE)));
38554 SWIG_Python_SetConstant(d, "MAILCAP_KDE",SWIG_From_int(static_cast< int >(wxMAILCAP_KDE)));
38555 SWIG_Python_SetConstant(d, "MAILCAP_GNOME",SWIG_From_int(static_cast< int >(wxMAILCAP_GNOME)));
38556 SWIG_Python_SetConstant(d, "MAILCAP_ALL",SWIG_From_int(static_cast< int >(wxMAILCAP_ALL)));
38557 SWIG_addvarlink(SWIG_globals(),(char*)"TheMimeTypesManager",TheMimeTypesManager_get, TheMimeTypesManager_set);
38558 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TOOLBAR",ART_TOOLBAR_get, ART_TOOLBAR_set);
38559 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MENU",ART_MENU_get, ART_MENU_set);
38560 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FRAME_ICON",ART_FRAME_ICON_get, ART_FRAME_ICON_set);
38561 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CMN_DIALOG",ART_CMN_DIALOG_get, ART_CMN_DIALOG_set);
38562 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BROWSER",ART_HELP_BROWSER_get, ART_HELP_BROWSER_set);
38563 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MESSAGE_BOX",ART_MESSAGE_BOX_get, ART_MESSAGE_BOX_set);
38564 SWIG_addvarlink(SWIG_globals(),(char*)"ART_BUTTON",ART_BUTTON_get, ART_BUTTON_set);
38565 SWIG_addvarlink(SWIG_globals(),(char*)"ART_OTHER",ART_OTHER_get, ART_OTHER_set);
38566 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ADD_BOOKMARK",ART_ADD_BOOKMARK_get, ART_ADD_BOOKMARK_set);
38567 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DEL_BOOKMARK",ART_DEL_BOOKMARK_get, ART_DEL_BOOKMARK_set);
38568 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SIDE_PANEL",ART_HELP_SIDE_PANEL_get, ART_HELP_SIDE_PANEL_set);
38569 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_SETTINGS",ART_HELP_SETTINGS_get, ART_HELP_SETTINGS_set);
38570 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_BOOK",ART_HELP_BOOK_get, ART_HELP_BOOK_set);
38571 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_FOLDER",ART_HELP_FOLDER_get, ART_HELP_FOLDER_set);
38572 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP_PAGE",ART_HELP_PAGE_get, ART_HELP_PAGE_set);
38573 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_BACK",ART_GO_BACK_get, ART_GO_BACK_set);
38574 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_FORWARD",ART_GO_FORWARD_get, ART_GO_FORWARD_set);
38575 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_UP",ART_GO_UP_get, ART_GO_UP_set);
38576 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DOWN",ART_GO_DOWN_get, ART_GO_DOWN_set);
38577 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_TO_PARENT",ART_GO_TO_PARENT_get, ART_GO_TO_PARENT_set);
38578 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_HOME",ART_GO_HOME_get, ART_GO_HOME_set);
38579 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_OPEN",ART_FILE_OPEN_get, ART_FILE_OPEN_set);
38580 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE",ART_FILE_SAVE_get, ART_FILE_SAVE_set);
38581 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FILE_SAVE_AS",ART_FILE_SAVE_AS_get, ART_FILE_SAVE_AS_set);
38582 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PRINT",ART_PRINT_get, ART_PRINT_set);
38583 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HELP",ART_HELP_get, ART_HELP_set);
38584 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TIP",ART_TIP_get, ART_TIP_set);
38585 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REPORT_VIEW",ART_REPORT_VIEW_get, ART_REPORT_VIEW_set);
38586 SWIG_addvarlink(SWIG_globals(),(char*)"ART_LIST_VIEW",ART_LIST_VIEW_get, ART_LIST_VIEW_set);
38587 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW_DIR",ART_NEW_DIR_get, ART_NEW_DIR_set);
38588 SWIG_addvarlink(SWIG_globals(),(char*)"ART_HARDDISK",ART_HARDDISK_get, ART_HARDDISK_set);
38589 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FLOPPY",ART_FLOPPY_get, ART_FLOPPY_set);
38590 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CDROM",ART_CDROM_get, ART_CDROM_set);
38591 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REMOVABLE",ART_REMOVABLE_get, ART_REMOVABLE_set);
38592 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER",ART_FOLDER_get, ART_FOLDER_set);
38593 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FOLDER_OPEN",ART_FOLDER_OPEN_get, ART_FOLDER_OPEN_set);
38594 SWIG_addvarlink(SWIG_globals(),(char*)"ART_GO_DIR_UP",ART_GO_DIR_UP_get, ART_GO_DIR_UP_set);
38595 SWIG_addvarlink(SWIG_globals(),(char*)"ART_EXECUTABLE_FILE",ART_EXECUTABLE_FILE_get, ART_EXECUTABLE_FILE_set);
38596 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NORMAL_FILE",ART_NORMAL_FILE_get, ART_NORMAL_FILE_set);
38597 SWIG_addvarlink(SWIG_globals(),(char*)"ART_TICK_MARK",ART_TICK_MARK_get, ART_TICK_MARK_set);
38598 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CROSS_MARK",ART_CROSS_MARK_get, ART_CROSS_MARK_set);
38599 SWIG_addvarlink(SWIG_globals(),(char*)"ART_ERROR",ART_ERROR_get, ART_ERROR_set);
38600 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUESTION",ART_QUESTION_get, ART_QUESTION_set);
38601 SWIG_addvarlink(SWIG_globals(),(char*)"ART_WARNING",ART_WARNING_get, ART_WARNING_set);
38602 SWIG_addvarlink(SWIG_globals(),(char*)"ART_INFORMATION",ART_INFORMATION_get, ART_INFORMATION_set);
38603 SWIG_addvarlink(SWIG_globals(),(char*)"ART_MISSING_IMAGE",ART_MISSING_IMAGE_get, ART_MISSING_IMAGE_set);
38604 SWIG_addvarlink(SWIG_globals(),(char*)"ART_COPY",ART_COPY_get, ART_COPY_set);
38605 SWIG_addvarlink(SWIG_globals(),(char*)"ART_CUT",ART_CUT_get, ART_CUT_set);
38606 SWIG_addvarlink(SWIG_globals(),(char*)"ART_PASTE",ART_PASTE_get, ART_PASTE_set);
38607 SWIG_addvarlink(SWIG_globals(),(char*)"ART_DELETE",ART_DELETE_get, ART_DELETE_set);
38608 SWIG_addvarlink(SWIG_globals(),(char*)"ART_NEW",ART_NEW_get, ART_NEW_set);
38609 SWIG_addvarlink(SWIG_globals(),(char*)"ART_UNDO",ART_UNDO_get, ART_UNDO_set);
38610 SWIG_addvarlink(SWIG_globals(),(char*)"ART_REDO",ART_REDO_get, ART_REDO_set);
38611 SWIG_addvarlink(SWIG_globals(),(char*)"ART_QUIT",ART_QUIT_get, ART_QUIT_set);
38612 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND",ART_FIND_get, ART_FIND_set);
38613 SWIG_addvarlink(SWIG_globals(),(char*)"ART_FIND_AND_REPLACE",ART_FIND_AND_REPLACE_get, ART_FIND_AND_REPLACE_set);
38614
38615 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
38616
38617 SWIG_Python_SetConstant(d, "CONFIG_USE_LOCAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_LOCAL_FILE)));
38618 SWIG_Python_SetConstant(d, "CONFIG_USE_GLOBAL_FILE",SWIG_From_int(static_cast< int >(wxCONFIG_USE_GLOBAL_FILE)));
38619 SWIG_Python_SetConstant(d, "CONFIG_USE_RELATIVE_PATH",SWIG_From_int(static_cast< int >(wxCONFIG_USE_RELATIVE_PATH)));
38620 SWIG_Python_SetConstant(d, "CONFIG_USE_NO_ESCAPE_CHARACTERS",SWIG_From_int(static_cast< int >(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
38621 SWIG_Python_SetConstant(d, "ConfigBase_Type_Unknown",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Unknown)));
38622 SWIG_Python_SetConstant(d, "ConfigBase_Type_String",SWIG_From_int(static_cast< int >(wxConfigBase::Type_String)));
38623 SWIG_Python_SetConstant(d, "ConfigBase_Type_Boolean",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Boolean)));
38624 SWIG_Python_SetConstant(d, "ConfigBase_Type_Integer",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Integer)));
38625 SWIG_Python_SetConstant(d, "ConfigBase_Type_Float",SWIG_From_int(static_cast< int >(wxConfigBase::Type_Float)));
38626 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTimeFormat",DefaultDateTimeFormat_get, DefaultDateTimeFormat_set);
38627 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultTimeSpanFormat",DefaultTimeSpanFormat_get, DefaultTimeSpanFormat_set);
38628 SWIG_Python_SetConstant(d, "DateTime_Local",SWIG_From_int(static_cast< int >(wxDateTime::Local)));
38629 SWIG_Python_SetConstant(d, "DateTime_GMT_12",SWIG_From_int(static_cast< int >(wxDateTime::GMT_12)));
38630 SWIG_Python_SetConstant(d, "DateTime_GMT_11",SWIG_From_int(static_cast< int >(wxDateTime::GMT_11)));
38631 SWIG_Python_SetConstant(d, "DateTime_GMT_10",SWIG_From_int(static_cast< int >(wxDateTime::GMT_10)));
38632 SWIG_Python_SetConstant(d, "DateTime_GMT_9",SWIG_From_int(static_cast< int >(wxDateTime::GMT_9)));
38633 SWIG_Python_SetConstant(d, "DateTime_GMT_8",SWIG_From_int(static_cast< int >(wxDateTime::GMT_8)));
38634 SWIG_Python_SetConstant(d, "DateTime_GMT_7",SWIG_From_int(static_cast< int >(wxDateTime::GMT_7)));
38635 SWIG_Python_SetConstant(d, "DateTime_GMT_6",SWIG_From_int(static_cast< int >(wxDateTime::GMT_6)));
38636 SWIG_Python_SetConstant(d, "DateTime_GMT_5",SWIG_From_int(static_cast< int >(wxDateTime::GMT_5)));
38637 SWIG_Python_SetConstant(d, "DateTime_GMT_4",SWIG_From_int(static_cast< int >(wxDateTime::GMT_4)));
38638 SWIG_Python_SetConstant(d, "DateTime_GMT_3",SWIG_From_int(static_cast< int >(wxDateTime::GMT_3)));
38639 SWIG_Python_SetConstant(d, "DateTime_GMT_2",SWIG_From_int(static_cast< int >(wxDateTime::GMT_2)));
38640 SWIG_Python_SetConstant(d, "DateTime_GMT_1",SWIG_From_int(static_cast< int >(wxDateTime::GMT_1)));
38641 SWIG_Python_SetConstant(d, "DateTime_GMT0",SWIG_From_int(static_cast< int >(wxDateTime::GMT0)));
38642 SWIG_Python_SetConstant(d, "DateTime_GMT1",SWIG_From_int(static_cast< int >(wxDateTime::GMT1)));
38643 SWIG_Python_SetConstant(d, "DateTime_GMT2",SWIG_From_int(static_cast< int >(wxDateTime::GMT2)));
38644 SWIG_Python_SetConstant(d, "DateTime_GMT3",SWIG_From_int(static_cast< int >(wxDateTime::GMT3)));
38645 SWIG_Python_SetConstant(d, "DateTime_GMT4",SWIG_From_int(static_cast< int >(wxDateTime::GMT4)));
38646 SWIG_Python_SetConstant(d, "DateTime_GMT5",SWIG_From_int(static_cast< int >(wxDateTime::GMT5)));
38647 SWIG_Python_SetConstant(d, "DateTime_GMT6",SWIG_From_int(static_cast< int >(wxDateTime::GMT6)));
38648 SWIG_Python_SetConstant(d, "DateTime_GMT7",SWIG_From_int(static_cast< int >(wxDateTime::GMT7)));
38649 SWIG_Python_SetConstant(d, "DateTime_GMT8",SWIG_From_int(static_cast< int >(wxDateTime::GMT8)));
38650 SWIG_Python_SetConstant(d, "DateTime_GMT9",SWIG_From_int(static_cast< int >(wxDateTime::GMT9)));
38651 SWIG_Python_SetConstant(d, "DateTime_GMT10",SWIG_From_int(static_cast< int >(wxDateTime::GMT10)));
38652 SWIG_Python_SetConstant(d, "DateTime_GMT11",SWIG_From_int(static_cast< int >(wxDateTime::GMT11)));
38653 SWIG_Python_SetConstant(d, "DateTime_GMT12",SWIG_From_int(static_cast< int >(wxDateTime::GMT12)));
38654 SWIG_Python_SetConstant(d, "DateTime_WET",SWIG_From_int(static_cast< int >(wxDateTime::WET)));
38655 SWIG_Python_SetConstant(d, "DateTime_WEST",SWIG_From_int(static_cast< int >(wxDateTime::WEST)));
38656 SWIG_Python_SetConstant(d, "DateTime_CET",SWIG_From_int(static_cast< int >(wxDateTime::CET)));
38657 SWIG_Python_SetConstant(d, "DateTime_CEST",SWIG_From_int(static_cast< int >(wxDateTime::CEST)));
38658 SWIG_Python_SetConstant(d, "DateTime_EET",SWIG_From_int(static_cast< int >(wxDateTime::EET)));
38659 SWIG_Python_SetConstant(d, "DateTime_EEST",SWIG_From_int(static_cast< int >(wxDateTime::EEST)));
38660 SWIG_Python_SetConstant(d, "DateTime_MSK",SWIG_From_int(static_cast< int >(wxDateTime::MSK)));
38661 SWIG_Python_SetConstant(d, "DateTime_MSD",SWIG_From_int(static_cast< int >(wxDateTime::MSD)));
38662 SWIG_Python_SetConstant(d, "DateTime_AST",SWIG_From_int(static_cast< int >(wxDateTime::AST)));
38663 SWIG_Python_SetConstant(d, "DateTime_ADT",SWIG_From_int(static_cast< int >(wxDateTime::ADT)));
38664 SWIG_Python_SetConstant(d, "DateTime_EST",SWIG_From_int(static_cast< int >(wxDateTime::EST)));
38665 SWIG_Python_SetConstant(d, "DateTime_EDT",SWIG_From_int(static_cast< int >(wxDateTime::EDT)));
38666 SWIG_Python_SetConstant(d, "DateTime_CST",SWIG_From_int(static_cast< int >(wxDateTime::CST)));
38667 SWIG_Python_SetConstant(d, "DateTime_CDT",SWIG_From_int(static_cast< int >(wxDateTime::CDT)));
38668 SWIG_Python_SetConstant(d, "DateTime_MST",SWIG_From_int(static_cast< int >(wxDateTime::MST)));
38669 SWIG_Python_SetConstant(d, "DateTime_MDT",SWIG_From_int(static_cast< int >(wxDateTime::MDT)));
38670 SWIG_Python_SetConstant(d, "DateTime_PST",SWIG_From_int(static_cast< int >(wxDateTime::PST)));
38671 SWIG_Python_SetConstant(d, "DateTime_PDT",SWIG_From_int(static_cast< int >(wxDateTime::PDT)));
38672 SWIG_Python_SetConstant(d, "DateTime_HST",SWIG_From_int(static_cast< int >(wxDateTime::HST)));
38673 SWIG_Python_SetConstant(d, "DateTime_AKST",SWIG_From_int(static_cast< int >(wxDateTime::AKST)));
38674 SWIG_Python_SetConstant(d, "DateTime_AKDT",SWIG_From_int(static_cast< int >(wxDateTime::AKDT)));
38675 SWIG_Python_SetConstant(d, "DateTime_A_WST",SWIG_From_int(static_cast< int >(wxDateTime::A_WST)));
38676 SWIG_Python_SetConstant(d, "DateTime_A_CST",SWIG_From_int(static_cast< int >(wxDateTime::A_CST)));
38677 SWIG_Python_SetConstant(d, "DateTime_A_EST",SWIG_From_int(static_cast< int >(wxDateTime::A_EST)));
38678 SWIG_Python_SetConstant(d, "DateTime_A_ESST",SWIG_From_int(static_cast< int >(wxDateTime::A_ESST)));
38679 SWIG_Python_SetConstant(d, "DateTime_UTC",SWIG_From_int(static_cast< int >(wxDateTime::UTC)));
38680 SWIG_Python_SetConstant(d, "DateTime_Gregorian",SWIG_From_int(static_cast< int >(wxDateTime::Gregorian)));
38681 SWIG_Python_SetConstant(d, "DateTime_Julian",SWIG_From_int(static_cast< int >(wxDateTime::Julian)));
38682 SWIG_Python_SetConstant(d, "DateTime_Gr_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Unknown)));
38683 SWIG_Python_SetConstant(d, "DateTime_Gr_Standard",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Standard)));
38684 SWIG_Python_SetConstant(d, "DateTime_Gr_Alaska",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Alaska)));
38685 SWIG_Python_SetConstant(d, "DateTime_Gr_Albania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Albania)));
38686 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria)));
38687 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Brixen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Brixen)));
38688 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Salzburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Salzburg)));
38689 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Tyrol",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Tyrol)));
38690 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Carinthia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Carinthia)));
38691 SWIG_Python_SetConstant(d, "DateTime_Gr_Austria_Styria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Austria_Styria)));
38692 SWIG_Python_SetConstant(d, "DateTime_Gr_Belgium",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Belgium)));
38693 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria)));
38694 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_1)));
38695 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_2)));
38696 SWIG_Python_SetConstant(d, "DateTime_Gr_Bulgaria_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Bulgaria_3)));
38697 SWIG_Python_SetConstant(d, "DateTime_Gr_Canada",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Canada)));
38698 SWIG_Python_SetConstant(d, "DateTime_Gr_China",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China)));
38699 SWIG_Python_SetConstant(d, "DateTime_Gr_China_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_1)));
38700 SWIG_Python_SetConstant(d, "DateTime_Gr_China_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_China_2)));
38701 SWIG_Python_SetConstant(d, "DateTime_Gr_Czechoslovakia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Czechoslovakia)));
38702 SWIG_Python_SetConstant(d, "DateTime_Gr_Denmark",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Denmark)));
38703 SWIG_Python_SetConstant(d, "DateTime_Gr_Egypt",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Egypt)));
38704 SWIG_Python_SetConstant(d, "DateTime_Gr_Estonia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Estonia)));
38705 SWIG_Python_SetConstant(d, "DateTime_Gr_Finland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Finland)));
38706 SWIG_Python_SetConstant(d, "DateTime_Gr_France",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France)));
38707 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Alsace",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Alsace)));
38708 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Lorraine",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Lorraine)));
38709 SWIG_Python_SetConstant(d, "DateTime_Gr_France_Strasbourg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_France_Strasbourg)));
38710 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany)));
38711 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Catholic)));
38712 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Prussia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Prussia)));
38713 SWIG_Python_SetConstant(d, "DateTime_Gr_Germany_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Germany_Protestant)));
38714 SWIG_Python_SetConstant(d, "DateTime_Gr_GreatBritain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_GreatBritain)));
38715 SWIG_Python_SetConstant(d, "DateTime_Gr_Greece",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Greece)));
38716 SWIG_Python_SetConstant(d, "DateTime_Gr_Hungary",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Hungary)));
38717 SWIG_Python_SetConstant(d, "DateTime_Gr_Ireland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Ireland)));
38718 SWIG_Python_SetConstant(d, "DateTime_Gr_Italy",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Italy)));
38719 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan)));
38720 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_1",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_1)));
38721 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_2",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_2)));
38722 SWIG_Python_SetConstant(d, "DateTime_Gr_Japan_3",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Japan_3)));
38723 SWIG_Python_SetConstant(d, "DateTime_Gr_Latvia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Latvia)));
38724 SWIG_Python_SetConstant(d, "DateTime_Gr_Lithuania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Lithuania)));
38725 SWIG_Python_SetConstant(d, "DateTime_Gr_Luxemburg",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Luxemburg)));
38726 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands)));
38727 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Groningen",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Groningen)));
38728 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Gelderland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Gelderland)));
38729 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Utrecht",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Utrecht)));
38730 SWIG_Python_SetConstant(d, "DateTime_Gr_Netherlands_Friesland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Netherlands_Friesland)));
38731 SWIG_Python_SetConstant(d, "DateTime_Gr_Norway",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Norway)));
38732 SWIG_Python_SetConstant(d, "DateTime_Gr_Poland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Poland)));
38733 SWIG_Python_SetConstant(d, "DateTime_Gr_Portugal",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Portugal)));
38734 SWIG_Python_SetConstant(d, "DateTime_Gr_Romania",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Romania)));
38735 SWIG_Python_SetConstant(d, "DateTime_Gr_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Russia)));
38736 SWIG_Python_SetConstant(d, "DateTime_Gr_Scotland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Scotland)));
38737 SWIG_Python_SetConstant(d, "DateTime_Gr_Spain",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Spain)));
38738 SWIG_Python_SetConstant(d, "DateTime_Gr_Sweden",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Sweden)));
38739 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland)));
38740 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Catholic",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Catholic)));
38741 SWIG_Python_SetConstant(d, "DateTime_Gr_Switzerland_Protestant",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Switzerland_Protestant)));
38742 SWIG_Python_SetConstant(d, "DateTime_Gr_Turkey",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Turkey)));
38743 SWIG_Python_SetConstant(d, "DateTime_Gr_USA",SWIG_From_int(static_cast< int >(wxDateTime::Gr_USA)));
38744 SWIG_Python_SetConstant(d, "DateTime_Gr_Wales",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Wales)));
38745 SWIG_Python_SetConstant(d, "DateTime_Gr_Yugoslavia",SWIG_From_int(static_cast< int >(wxDateTime::Gr_Yugoslavia)));
38746 SWIG_Python_SetConstant(d, "DateTime_Country_Unknown",SWIG_From_int(static_cast< int >(wxDateTime::Country_Unknown)));
38747 SWIG_Python_SetConstant(d, "DateTime_Country_Default",SWIG_From_int(static_cast< int >(wxDateTime::Country_Default)));
38748 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_Start",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_Start)));
38749 SWIG_Python_SetConstant(d, "DateTime_Country_EEC",SWIG_From_int(static_cast< int >(wxDateTime::Country_EEC)));
38750 SWIG_Python_SetConstant(d, "DateTime_France",SWIG_From_int(static_cast< int >(wxDateTime::France)));
38751 SWIG_Python_SetConstant(d, "DateTime_Germany",SWIG_From_int(static_cast< int >(wxDateTime::Germany)));
38752 SWIG_Python_SetConstant(d, "DateTime_UK",SWIG_From_int(static_cast< int >(wxDateTime::UK)));
38753 SWIG_Python_SetConstant(d, "DateTime_Country_WesternEurope_End",SWIG_From_int(static_cast< int >(wxDateTime::Country_WesternEurope_End)));
38754 SWIG_Python_SetConstant(d, "DateTime_Russia",SWIG_From_int(static_cast< int >(wxDateTime::Russia)));
38755 SWIG_Python_SetConstant(d, "DateTime_USA",SWIG_From_int(static_cast< int >(wxDateTime::USA)));
38756 SWIG_Python_SetConstant(d, "DateTime_Jan",SWIG_From_int(static_cast< int >(wxDateTime::Jan)));
38757 SWIG_Python_SetConstant(d, "DateTime_Feb",SWIG_From_int(static_cast< int >(wxDateTime::Feb)));
38758 SWIG_Python_SetConstant(d, "DateTime_Mar",SWIG_From_int(static_cast< int >(wxDateTime::Mar)));
38759 SWIG_Python_SetConstant(d, "DateTime_Apr",SWIG_From_int(static_cast< int >(wxDateTime::Apr)));
38760 SWIG_Python_SetConstant(d, "DateTime_May",SWIG_From_int(static_cast< int >(wxDateTime::May)));
38761 SWIG_Python_SetConstant(d, "DateTime_Jun",SWIG_From_int(static_cast< int >(wxDateTime::Jun)));
38762 SWIG_Python_SetConstant(d, "DateTime_Jul",SWIG_From_int(static_cast< int >(wxDateTime::Jul)));
38763 SWIG_Python_SetConstant(d, "DateTime_Aug",SWIG_From_int(static_cast< int >(wxDateTime::Aug)));
38764 SWIG_Python_SetConstant(d, "DateTime_Sep",SWIG_From_int(static_cast< int >(wxDateTime::Sep)));
38765 SWIG_Python_SetConstant(d, "DateTime_Oct",SWIG_From_int(static_cast< int >(wxDateTime::Oct)));
38766 SWIG_Python_SetConstant(d, "DateTime_Nov",SWIG_From_int(static_cast< int >(wxDateTime::Nov)));
38767 SWIG_Python_SetConstant(d, "DateTime_Dec",SWIG_From_int(static_cast< int >(wxDateTime::Dec)));
38768 SWIG_Python_SetConstant(d, "DateTime_Inv_Month",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Month)));
38769 SWIG_Python_SetConstant(d, "DateTime_Sun",SWIG_From_int(static_cast< int >(wxDateTime::Sun)));
38770 SWIG_Python_SetConstant(d, "DateTime_Mon",SWIG_From_int(static_cast< int >(wxDateTime::Mon)));
38771 SWIG_Python_SetConstant(d, "DateTime_Tue",SWIG_From_int(static_cast< int >(wxDateTime::Tue)));
38772 SWIG_Python_SetConstant(d, "DateTime_Wed",SWIG_From_int(static_cast< int >(wxDateTime::Wed)));
38773 SWIG_Python_SetConstant(d, "DateTime_Thu",SWIG_From_int(static_cast< int >(wxDateTime::Thu)));
38774 SWIG_Python_SetConstant(d, "DateTime_Fri",SWIG_From_int(static_cast< int >(wxDateTime::Fri)));
38775 SWIG_Python_SetConstant(d, "DateTime_Sat",SWIG_From_int(static_cast< int >(wxDateTime::Sat)));
38776 SWIG_Python_SetConstant(d, "DateTime_Inv_WeekDay",SWIG_From_int(static_cast< int >(wxDateTime::Inv_WeekDay)));
38777 SWIG_Python_SetConstant(d, "DateTime_Inv_Year",SWIG_From_int(static_cast< int >(wxDateTime::Inv_Year)));
38778 SWIG_Python_SetConstant(d, "DateTime_Name_Full",SWIG_From_int(static_cast< int >(wxDateTime::Name_Full)));
38779 SWIG_Python_SetConstant(d, "DateTime_Name_Abbr",SWIG_From_int(static_cast< int >(wxDateTime::Name_Abbr)));
38780 SWIG_Python_SetConstant(d, "DateTime_Default_First",SWIG_From_int(static_cast< int >(wxDateTime::Default_First)));
38781 SWIG_Python_SetConstant(d, "DateTime_Monday_First",SWIG_From_int(static_cast< int >(wxDateTime::Monday_First)));
38782 SWIG_Python_SetConstant(d, "DateTime_Sunday_First",SWIG_From_int(static_cast< int >(wxDateTime::Sunday_First)));
38783 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultDateTime",DefaultDateTime_get, DefaultDateTime_set);
38784 SWIG_Python_SetConstant(d, "DF_INVALID",SWIG_From_int(static_cast< int >(wxDF_INVALID)));
38785 SWIG_Python_SetConstant(d, "DF_TEXT",SWIG_From_int(static_cast< int >(wxDF_TEXT)));
38786 SWIG_Python_SetConstant(d, "DF_BITMAP",SWIG_From_int(static_cast< int >(wxDF_BITMAP)));
38787 SWIG_Python_SetConstant(d, "DF_METAFILE",SWIG_From_int(static_cast< int >(wxDF_METAFILE)));
38788 SWIG_Python_SetConstant(d, "DF_SYLK",SWIG_From_int(static_cast< int >(wxDF_SYLK)));
38789 SWIG_Python_SetConstant(d, "DF_DIF",SWIG_From_int(static_cast< int >(wxDF_DIF)));
38790 SWIG_Python_SetConstant(d, "DF_TIFF",SWIG_From_int(static_cast< int >(wxDF_TIFF)));
38791 SWIG_Python_SetConstant(d, "DF_OEMTEXT",SWIG_From_int(static_cast< int >(wxDF_OEMTEXT)));
38792 SWIG_Python_SetConstant(d, "DF_DIB",SWIG_From_int(static_cast< int >(wxDF_DIB)));
38793 SWIG_Python_SetConstant(d, "DF_PALETTE",SWIG_From_int(static_cast< int >(wxDF_PALETTE)));
38794 SWIG_Python_SetConstant(d, "DF_PENDATA",SWIG_From_int(static_cast< int >(wxDF_PENDATA)));
38795 SWIG_Python_SetConstant(d, "DF_RIFF",SWIG_From_int(static_cast< int >(wxDF_RIFF)));
38796 SWIG_Python_SetConstant(d, "DF_WAVE",SWIG_From_int(static_cast< int >(wxDF_WAVE)));
38797 SWIG_Python_SetConstant(d, "DF_UNICODETEXT",SWIG_From_int(static_cast< int >(wxDF_UNICODETEXT)));
38798 SWIG_Python_SetConstant(d, "DF_ENHMETAFILE",SWIG_From_int(static_cast< int >(wxDF_ENHMETAFILE)));
38799 SWIG_Python_SetConstant(d, "DF_FILENAME",SWIG_From_int(static_cast< int >(wxDF_FILENAME)));
38800 SWIG_Python_SetConstant(d, "DF_LOCALE",SWIG_From_int(static_cast< int >(wxDF_LOCALE)));
38801 SWIG_Python_SetConstant(d, "DF_PRIVATE",SWIG_From_int(static_cast< int >(wxDF_PRIVATE)));
38802 SWIG_Python_SetConstant(d, "DF_HTML",SWIG_From_int(static_cast< int >(wxDF_HTML)));
38803 SWIG_Python_SetConstant(d, "DF_MAX",SWIG_From_int(static_cast< int >(wxDF_MAX)));
38804 SWIG_addvarlink(SWIG_globals(),(char*)"FormatInvalid",FormatInvalid_get, FormatInvalid_set);
38805 SWIG_Python_SetConstant(d, "DataObject_Get",SWIG_From_int(static_cast< int >(wxDataObject::Get)));
38806 SWIG_Python_SetConstant(d, "DataObject_Set",SWIG_From_int(static_cast< int >(wxDataObject::Set)));
38807 SWIG_Python_SetConstant(d, "DataObject_Both",SWIG_From_int(static_cast< int >(wxDataObject::Both)));
38808 SWIG_Python_SetConstant(d, "Drag_CopyOnly",SWIG_From_int(static_cast< int >(wxDrag_CopyOnly)));
38809 SWIG_Python_SetConstant(d, "Drag_AllowMove",SWIG_From_int(static_cast< int >(wxDrag_AllowMove)));
38810 SWIG_Python_SetConstant(d, "Drag_DefaultMove",SWIG_From_int(static_cast< int >(wxDrag_DefaultMove)));
38811 SWIG_Python_SetConstant(d, "DragError",SWIG_From_int(static_cast< int >(wxDragError)));
38812 SWIG_Python_SetConstant(d, "DragNone",SWIG_From_int(static_cast< int >(wxDragNone)));
38813 SWIG_Python_SetConstant(d, "DragCopy",SWIG_From_int(static_cast< int >(wxDragCopy)));
38814 SWIG_Python_SetConstant(d, "DragMove",SWIG_From_int(static_cast< int >(wxDragMove)));
38815 SWIG_Python_SetConstant(d, "DragLink",SWIG_From_int(static_cast< int >(wxDragLink)));
38816 SWIG_Python_SetConstant(d, "DragCancel",SWIG_From_int(static_cast< int >(wxDragCancel)));
38817
38818 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
38819 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
38820 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
38821 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
38822
38823 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultVideoMode",DefaultVideoMode_get, DefaultVideoMode_set);
38824 }
38825
wxWidgets (Impactor)